QuantPngQuant.c

/*
 * The Python Imaging Library
 * $Id$
 *
 * quantization using libimagequant, a part of pngquant.
 *
 * Copyright (c) 2016 Marcin Kurczewski <rr-@sakuya.pl>
 *
 */

#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "QuantPngQuant.h"

#ifdef HAVE_LIBIMAGEQUANT
#include "libimagequant.h"

int
quantize_pngquant(
    Pixel *pixelData,
    unsigned int width,
    unsigned int height,
    uint32_t quantPixels,
    Pixel **palette,
    uint32_t *paletteLength,
    uint32_t **quantizedPixels,
    int withAlpha
) {
    int result = 0;
    liq_image *image = NULL;
    liq_attr *attr = NULL;
    liq_result *remap = NULL;
    unsigned char *charMatrix = NULL;
    unsigned char **charMatrixRows = NULL;
    unsigned int i, y;
    *palette = NULL;
    *paletteLength = 0;
    *quantizedPixels = NULL;

    /* Check for integer overflow in width * height to prevent
     * undersized allocations leading to heap buffer overflow. */
    if (height != 0 && (size_t)width > SIZE_MAX / (size_t)height) {
        goto err;
    }
    size_t total_pixels = (size_t)width * (size_t)height;

    /* configure pngquant */
    attr = liq_attr_create();
    if (!attr) {
        goto err;
    }
    if (quantPixels) {
        liq_set_max_colors(attr, quantPixels);
    }

    /* prepare input image */
    image = liq_image_create_rgba(attr, pixelData, width, height, 0.45455 /* gamma */);
    if (!image) {
        goto err;
    }

    /* quantize the image */
    remap = liq_quantize_image(attr, image);
    if (!remap) {
        goto err;
    }
    liq_set_output_gamma(remap, 0.45455);
    liq_set_dithering_level(remap, 1);

    /* write output palette */
    const liq_palette *l_palette = liq_get_palette(remap);
    *paletteLength = l_palette->count;
    *palette = malloc(sizeof(Pixel) * l_palette->count);
    if (!*palette) {
        goto err;
    }
    for (i = 0; i < l_palette->count; i++) {
        (*palette)[i].c.b = l_palette->entries[i].b;
        (*palette)[i].c.g = l_palette->entries[i].g;
        (*palette)[i].c.r = l_palette->entries[i].r;
        (*palette)[i].c.a = l_palette->entries[i].a;
    }

    /* write output pixels (pngquant uses char array) */
    charMatrix = malloc(total_pixels);
    if (!charMatrix) {
        goto err;
    }
    charMatrixRows = malloc(height * sizeof(unsigned char *));
    if (!charMatrixRows) {
        goto err;
    }
    for (y = 0; y < height; y++) {
        charMatrixRows[y] = &charMatrix[(size_t)y * width];
    }
    if (LIQ_OK != liq_write_remapped_image_rows(remap, image, charMatrixRows)) {
        goto err;
    }

    /* transcribe output pixels (pillow uses uint32_t array) */
    *quantizedPixels = malloc(sizeof(uint32_t) * total_pixels);
    if (!*quantizedPixels) {
        goto err;
    }
    for (i = 0; i < total_pixels; i++) {
        (*quantizedPixels)[i] = charMatrix[i];
    }

    result = 1;

err:
    if (attr) {
        liq_attr_destroy(attr);
    }
    if (image) {
        liq_image_destroy(image);
    }
    if (remap) {
        liq_result_destroy(remap);
    }
    free(charMatrix);
    free(charMatrixRows);
    if (!result) {
        free(*quantizedPixels);
        free(*palette);
    }
    return result;
}

const char *
ImagingImageQuantVersion(void) {
    static char version[20];
    int number = liq_version();
    snprintf(
        version,
        sizeof(version),
        "%d.%d.%d",
        number / 10000,
        (number / 100) % 100,
        number % 100
    );
    return version;
}

#endif