发生错误时返回NULL。

void liq_attr_destroy(liq_attr *);
void liq_image_destroy(liq_image *);
void liq_result_destroy(liq_result *);
void liq_histogram_destroy(liq_histogram *);

释放给定对象拥有的内存。对象在释放后不得再使用。

释放liq_result也会释放从它获得的任何liq_palette。

高级功能

liq_error liq_set_speed(liq_attr* attr, int speed);

较高的速度级别禁用昂贵的算法并减少量化精度。默认速度是4。速度1在显著的CPU成本下提供略微更好的质量。速度10通常质量降低5%，但比默认值快8倍。

与liq_set_quality()结合使用的高速度将使用比必要的更多颜色，并且不太可能达到最低所需质量。

如果速度超出1-10的范围，则返回LIQ_VALUE_OUT_OF_RANGE。

int liq_get_speed(liq_attr* attr);

返回由liq_set_speed()设置的值。

liq_error liq_set_min_opacity(liq_attr* attr, int min);

这是一个针对Internet Explorer 6的解决方案，但由于这个浏览器已经不再使用，这个选项已被弃用并删除。

int liq_get_min_opacity(liq_attr* attr);

此功能已被弃用。

liq_set_min_posterization(liq_attr* attr, int bits);

忽略所有通道中给定数量的最低有效位，将图像转换为 2^bits 级别的伪影。 0 表示全质量。使用 2 对于VGA或16位RGB565显示，如果图像将被输出到RGB444/RGBA4444显示（例如，Android上的低质量纹理），则使用 4。

如果值超出0-4的范围，则返回 LIQ_VALUE_OUT_OF_RANGE。

int liq_get_min_posterization(liq_attr* attr);

返回由 liq_set_min_posterization() 设置的值。

liq_set_last_index_transparent(liq_attr* attr, int is_last);

0（默认）使alpha颜色在不透明颜色之前排序。非 0 混合颜色，除了完全透明的颜色，它被移动到调色板的末尾。这是针对盲目假设最后一个调色板条目是透明的程序的一个解决方案。

liq_image *liq_image_create_custom(liq_attr *attr, liq_image_get_rgba_row_callback *row_callback, void *user_info, int width, int height, double gamma);

void image_get_rgba_row_callback(liq_color row_out[], int row_index, int width, void *user_info) {
    for(int column_index=0; column_index < width; column_index++) {
        row_out[column_index] = /* generate pixel at (row_index, column_index) */;
    }
}

创建一个使用回调来读取图像数据的图像对象。这允许实时转换不是在RGBA颜色空间中的图像。

user_info 值将被传递给回调。这可能有助于存储指向程序内部图像表示的指针。

回调必须读取/生成 row_index 第行的数据，并将其RGBA像素写入 row_out 数组。为了方便起见，给出了行 width，它始终等于图像宽度。

对于每一行，回调将被多次调用。量化重映射至少需要遍历两次图像数据，因此缓存回调的工作没有意义——在这种情况下，最好转换整个图像并使用 liq_image_create_rgba()。

void rgb_to_rgba_callback(liq_color row_out[], int row_index, int width, void *user_info) {
    unsigned char *rgb_row = ((unsigned char *)user_info) + 3*width*row_index;

    for(int i=0; i < width; i++) {
        row_out[i].r = rgb_row[i*3];
        row_out[i].g = rgb_row[i*3+1];
        row_out[i].b = rgb_row[i*3+2];
        row_out[i].a = 255;
    }
}
liq_image *img = liq_image_create_custom(attr, rgb_to_rgba_callback, rgb_bitmap, width, height, 0);

liq_error liq_image_set_memory_ownership(liq_image *image, int ownership_flags);

liq_error liq_image_set_background(liq_image *image, liq_image *background_image);

liq_error liq_image_set_importance_map(liq_image *image, unsigned char map[], size_t buffer_size, liq_ownership ownership);

liq_error liq_write_remapped_image_rows(liq_result *result, liq_image *input_image, unsigned char **row_pointers);

double liq_get_quantization_error(liq_result *result);

double liq_get_remapping_error(liq_result *result);

double liq_get_quantization_quality(liq_result *result);

liq_attr *attr = liq_attr_create();
liq_image *img = liq_image_create_rgba(…);
liq_result *res;
liq_image_quantize(img, attr, &res);
int max_attainable_quality = liq_get_quantization_quality(res);
printf("Please select quality between 0 and %d: ", max_attainable_quality);
int user_selected_quality = prompt();
if (user_selected_quality < max_attainable_quality) {
    liq_set_quality(user_selected_quality, 0);
    liq_result_destroy(res);
    liq_image_quantize(img, attr, &res);
}
liq_write_remapped_image(…);

double liq_get_remapping_quality(liq_result *result);

void liq_set_log_callback(liq_attr*, liq_log_callback_function*, void *user_info);

void log_callback_function(const liq_attr*, const char *message, void *user_info) {}

void liq_set_log_flush_callback(liq_attr*, liq_log_flush_callback_function*, void *user_info);

void log_flush_callback_function(const liq_attr*, void *user_info) {}

void liq_set_progress_callback(liq_attr*, liq_progress_callback_function*, void *user_info);
void liq_result_set_progress_callback(liq_result*, liq_progress_callback_function*, void *user_info);

int progress_callback_function(const liq_attr*, float progress_percent, void *user_info) {}

liq_attr* liq_attr_create_with_allocator(void* (*malloc)(size_t), void (*free)(void*));

liq_attr* liq_attr_copy(liq_attr *orig);

liq_error liq_set_output_gamma(liq_result* res, double gamma);

int liq_image_get_width(const liq_image *img);
int liq_image_get_height(const liq_image *img);
double liq_get_output_gamma(const liq_result *result);

liq_error liq_image_add_fixed_color(liq_image* img, liq_color color);
liq_error liq_histogram_add_fixed_color(liq_histogram* hist, liq_color color, double gamma);

int liq_version();

liq_attr *attr = liq_attr_create();
liq_histogram *hist = liq_histogram_create(attr);

liq_image *image1 = liq_image_create_rgba(attr, example_bitmap_rgba1, width, height, 0);
liq_histogram_add_image(hist, attr, image1);

liq_image *image2 = liq_image_create_rgba(attr, example_bitmap_rgba2, width, height, 0);
liq_histogram_add_image(hist, attr, image2);

liq_result *result;
liq_error err = liq_histogram_quantize(attr, hist, &result);
if (LIQ_OK == err) {
    // result will contain shared palette best for both image1 and image2
}

liq_histogram *liq_histogram_create(liq_attr *attr);

liq_error liq_histogram_add_image(liq_histogram *hist, liq_attr *attr, liq_image* image);

liq_error liq_histogram_add_colors(liq_histogram *hist, liq_attr *attr, liq_histogram_entry entries[], int num_entries, double gamma);

liq_error liq_histogram_quantize(liq_histogram *const hist, liq_attr *const attr, liq_result **out_result);

liq_result *result;
liq_error err = liq_histogram_quantize(attr, hist, &result);
if (LIQ_OK == err) {
    // Use result here to remap and get palette
}