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

@@ -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 <http://www.gnu.org/licenses/>.
+*/
+
+#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);
+}

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

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 <stdlib.h>
+#include <string.h>
+
+#ifdef _OPENMP
+#include <omp.h>
+#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;
+}

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

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 <stddef.h>
+
+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

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 <stdlib.h>
+#include <stddef.h>
+
+#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 and >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};
+}

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

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 <stdlib.h>
+#include <stdint.h>
+#include <assert.h>
+
+#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;
+    }
+}

src/platform/gba/packer/libimagequant/mempool.h

@@ -0,0 +1,13 @@
+#ifndef MEMPOOL_H
+#define MEMPOOL_H
+
+#include <stddef.h>
+
+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

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 <stdlib.h>
+
+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);
+}

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

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 <stdlib.h>
+#include <string.h>
+
+#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;
+    const unsigned int channel_hmask = (255U>>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);
+    }
+}
+

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 <math.h>
+#include <assert.h>
+#include <stdlib.h>
+#include <stdbool.h>
+
+#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 <xmmintrin.h>
+#  ifdef _MSC_VER
+#    include <intrin.h>
+#    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