295 lines
7.1 KiB
C
295 lines
7.1 KiB
C
#include "imagecon.h"
|
|
|
|
static void
|
|
_sham_generateLinePalette(imagecon_image_t* ic, int line);
|
|
static void
|
|
_sham_outputCopperLine(imagecon_image_t* ic, FILE* fp, int line);
|
|
|
|
static FILE* _copperFP;
|
|
static amiga_color_t *combos;
|
|
static int totalCombinations = 16*16*16;
|
|
|
|
static amiga_color_t
|
|
_sham_getHamColor(dither_data_t data)
|
|
{
|
|
static int row = -1;
|
|
|
|
if (row != data.y) {
|
|
row = data.y;
|
|
_sham_generateLinePalette(data.ic, row);
|
|
_sham_outputCopperLine(data.ic, _copperFP, row);
|
|
}
|
|
|
|
|
|
ham_control_t ham = ham_findClosestPixel(data.ic, data.color, data.last);
|
|
return ham.pixel;
|
|
}
|
|
|
|
|
|
static ham_control_t*
|
|
_sham_createHams(imagecon_image_t* ic)
|
|
{
|
|
ham_control_t* hams = malloc(sizeof(ham_control_t)*ic->width*ic->height);
|
|
|
|
for (int y = 0; y < ic->height; y++) {
|
|
amiga_color_t lastPixel = { -1, -1, -1, -1};
|
|
_sham_generateLinePalette(ic, y);
|
|
for (int x = 0; x < ic->width; x++) {
|
|
amiga_color_t orig = color_ditheredToAmiga(color_getDitheredPixel(ic, x, y));
|
|
ham_control_t ham = ham_findClosestPixel(ic, orig, lastPixel);
|
|
lastPixel = ham.pixel;
|
|
hams[(y*ic->width)+x] = ham;
|
|
}
|
|
}
|
|
|
|
return hams;
|
|
}
|
|
|
|
static int
|
|
_score(imagecon_image_t* ic, int y)
|
|
{
|
|
long error = 0;
|
|
amiga_color_t lastPixel = { -1, -1, -1, -1};
|
|
for (int x = 0; x < ic->width; x++) {
|
|
amiga_color_t color = color_getOriginalPixel(ic, x, y);
|
|
ham_control_t ham = ham_findClosestPixel(ic, color, lastPixel);
|
|
error += color_delta(color, color_findClosestPalettePixel(ic, ham.pixel));
|
|
lastPixel = ham.pixel;
|
|
}
|
|
|
|
return error;
|
|
}
|
|
|
|
static void
|
|
_sham_bruteForceInit(imagecon_image_t* ic)
|
|
{
|
|
combos = malloc(sizeof(amiga_color_t)*totalCombinations);
|
|
int index = 0;
|
|
for (unsigned char r = 0; r <= 0xF; r++) {
|
|
for (unsigned char g = 0; g <= 0xF; g++) {
|
|
for (unsigned char b = 0; b <= 0xF; b++) {
|
|
combos[index].a = 255;
|
|
combos[index].r = r<<4;
|
|
combos[index].g = g<<4;
|
|
combos[index++].b = b<<4;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
static void
|
|
_sham_bruteForceLinePalette(imagecon_image_t* ic, int row)
|
|
{
|
|
int length = 16;
|
|
|
|
bzero(ic->palette, sizeof(ic->palette));
|
|
ic->numColors = 16;
|
|
|
|
int step = 1;
|
|
long big = totalCombinations*length;
|
|
long b = 0;
|
|
|
|
for (int x = 0; x < length; x++) {
|
|
long benchmark = LONG_MAX;
|
|
int bmIndex = 0;
|
|
for (int i = 0; i < totalCombinations; i+=step, b+=step) {
|
|
ic->palette[x] = combos[i];
|
|
fflush(stdout);
|
|
printf("%c7", 27);
|
|
fflush(stdout);
|
|
printf(" %03d %05ld/%05ld (%ld%%)", row, b, big, (b*100L)/big);
|
|
fflush(stdout);
|
|
printf("%c8", 27);
|
|
fflush(stdout);
|
|
long score = _score(ic, row);
|
|
if (score < benchmark) {
|
|
benchmark = score;
|
|
bmIndex = i;
|
|
}
|
|
}
|
|
ic->palette[x] = combos[bmIndex];
|
|
|
|
|
|
}
|
|
}
|
|
|
|
|
|
static void
|
|
_sham_generateQuantizedLinePalette(imagecon_image_t* ic, int line)
|
|
{
|
|
liq_attr *attr = liq_attr_create();
|
|
|
|
void* ptr[1] = { &ic->rowPointers[line] };
|
|
liq_image *image = liq_image_create_rgba_rows(attr, ptr, ic->width, 1, /* gamma */0.0);
|
|
|
|
liq_set_max_colors(attr, config.maxColors);
|
|
|
|
liq_color color = {.a = 255, .r = 0, .b = 0, .g = 0};
|
|
liq_image_add_fixed_color(image, color);
|
|
liq_result *res = liq_quantize_image(attr, image);
|
|
|
|
const liq_palette *pal = liq_get_palette(res);
|
|
|
|
if (config.verbose) {
|
|
printf("_sham_generateQuantizedLinePalette: pal->count = %d\n", pal->count);
|
|
}
|
|
|
|
for (unsigned i = 0; i < pal->count; i++) {
|
|
ic->palette[i].r = pal->entries[i].r;
|
|
ic->palette[i].g = pal->entries[i].g;
|
|
ic->palette[i].b = pal->entries[i].b;
|
|
ic->palette[i].a = pal->entries[i].a;
|
|
}
|
|
|
|
for (unsigned i = 0; i < pal->count; i++) {
|
|
if (ic->palette[i].r == 0 &&
|
|
ic->palette[i].g == 0 &&
|
|
ic->palette[i].b == 0 &&
|
|
ic->palette[i].a == 255) {
|
|
|
|
if (i != 0) {
|
|
amiga_color_t black = ic->palette[i];
|
|
amiga_color_t other = ic->palette[0];
|
|
ic->palette[0] = black;
|
|
ic->palette[i] = other;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
ic->numColors = pal->count;
|
|
|
|
for (int i = 0; i < ic->numColors; i++) {
|
|
if (config.verbose) {
|
|
printf("%02d: r=%03d g=%03d b=%03d a=%03d\n", i, ic->palette[i].r, ic->palette[i].g, ic->palette[i].b, ic->palette[i].a);
|
|
}
|
|
}
|
|
|
|
liq_attr_destroy(attr);
|
|
liq_image_destroy(image);
|
|
liq_result_destroy(res);
|
|
}
|
|
|
|
static void
|
|
_sham_generateLinePalette(imagecon_image_t* ic, int line)
|
|
{
|
|
if (config.hamBruteForce) {
|
|
_sham_bruteForceLinePalette(ic, line);
|
|
} else {
|
|
_sham_generateQuantizedLinePalette(ic, line);
|
|
}
|
|
|
|
}
|
|
|
|
static void
|
|
_sham_outputCopperLine(imagecon_image_t* ic, FILE* fp, int line)
|
|
{
|
|
int endPos = 0xe1;
|
|
|
|
line = line+0x2c-1;
|
|
if (line <= 255) {
|
|
fprintf(fp, "\tdc.w $%x,$fffe\n",(line)<<8|endPos|1);
|
|
} else {
|
|
fprintf(fp, "\tdc.w $%x,$fffe\n", ((line)-256)<<8|endPos|1);
|
|
}
|
|
|
|
for (int i = 1; i < ic->numColors; i++) {
|
|
fprintf(fp, "\tdc.w $%x,$%x\n", 0x180+(i*2), RGB24TORGB12(ic->palette[i].r) << 8 | RGB24TORGB12(ic->palette[i].g) << 4 | RGB24TORGB12(ic->palette[i].b));
|
|
}
|
|
|
|
|
|
}
|
|
|
|
static void
|
|
_sham_outputBitplanes(imagecon_image_t* ic, FILE* copperFP, FILE* bitplaneFP)
|
|
{
|
|
|
|
int numBitPlanes = 6;
|
|
int byteWidth = (ic->width + 7) / 8;
|
|
|
|
char** bitplanes = malloc(sizeof(void*)*numBitPlanes);
|
|
for (int i = 0; i < numBitPlanes; i++) {
|
|
bitplanes[i] = calloc(byteWidth*ic->height, 1);
|
|
}
|
|
|
|
ham_control_t* hams;
|
|
|
|
if (config.dither) {
|
|
dither_image(ic, _sham_getHamColor);
|
|
hams = _sham_createHams(ic);
|
|
} else {
|
|
hams = malloc(sizeof(ham_control_t)*ic->width*ic->height);
|
|
|
|
for (int y = 0; y < ic->height; y++) {
|
|
_sham_generateLinePalette(ic, y);
|
|
_sham_outputCopperLine(ic, copperFP, y);
|
|
amiga_color_t lastPixel = { -1, -1, -1, -1};
|
|
for (int x = 0; x < ic->width; x++) {
|
|
amiga_color_t orig = color_getOriginalPixel(ic, x, y);
|
|
ham_control_t ham = ham_findClosestPixel(ic, orig, lastPixel);
|
|
lastPixel = ham.pixel;
|
|
hams[(y*ic->width)+x] = ham;
|
|
}
|
|
}
|
|
}
|
|
|
|
for (int y = 0, writeIndex = 0; y < ic->height; y++) {
|
|
for (int byte = 0;byte < byteWidth; byte++) {
|
|
for (int bit = 0; bit < 8; bit++) {
|
|
int x = byte * 8 + 7 - bit;
|
|
ham_control_t ham = hams[(y*ic->width)+x];
|
|
int _numBitPlanes = 4;
|
|
for (int plane_index = 0; plane_index < _numBitPlanes; plane_index++) {
|
|
char* plane = bitplanes[plane_index];
|
|
plane[writeIndex] |= ((ham.data >> plane_index) & 1) << bit;
|
|
}
|
|
|
|
for (int plane_index = 0; plane_index < 2; plane_index++) {
|
|
char* plane = bitplanes[4+plane_index];
|
|
plane[writeIndex] |= ((ham.control >> plane_index) & 1) << bit;
|
|
}
|
|
|
|
|
|
}
|
|
writeIndex++;
|
|
}
|
|
}
|
|
|
|
|
|
for (int y = 0; y < ic->height; y++) {
|
|
for (int plane_index = 0; plane_index < numBitPlanes; plane_index++) {
|
|
char* plane = bitplanes[plane_index];
|
|
fwrite(&plane[y*byteWidth], byteWidth, 1, bitplaneFP);
|
|
}
|
|
}
|
|
|
|
|
|
if (config.verbose) {
|
|
printf("done\n\n");
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
|
sham_process(imagecon_image_t* ic, char* outFilename)
|
|
{
|
|
config.maxColors = 16;
|
|
|
|
_copperFP = file_openWrite("%s-sham-copper.s", outFilename);
|
|
FILE* bitplaneFP = file_openWrite("%s-sham.bin", outFilename);
|
|
|
|
if (config.hamBruteForce) {
|
|
_sham_bruteForceInit(ic);
|
|
}
|
|
|
|
if (config.outputBitplanes) {
|
|
_sham_outputBitplanes(ic, _copperFP, bitplaneFP);
|
|
}
|
|
|
|
fclose(_copperFP);
|
|
fclose(bitplaneFP);
|
|
}
|
|
|