You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
430 lines
11 KiB
430 lines
11 KiB
/* makesRGB.c -- build sRGB-to-linear and linear-to-sRGB conversion tables |
|
* |
|
* Last changed in libpng 1.6.0 [February 14, 2013] |
|
* |
|
* COPYRIGHT: Written by John Cunningham Bowler, 2013. |
|
* To the extent possible under law, the author has waived all copyright and |
|
* related or neighboring rights to this work. This work is published from: |
|
* United States. |
|
* |
|
* Make a table to convert 8-bit sRGB encoding values into the closest 16-bit |
|
* linear value. |
|
* |
|
* Make two tables to take a linear value scaled to 255*65535 and return an |
|
* approximation to the 8-bit sRGB encoded value. Calculate the error in these |
|
* tables and display it. |
|
*/ |
|
#define _C99_SOURCE 1 |
|
#include <stdio.h> |
|
#include <math.h> |
|
#include <stdlib.h> |
|
|
|
/* pngpriv.h includes the definition of 'PNG_sRGB_FROM_LINEAR' which is required |
|
* to verify the actual code. |
|
*/ |
|
#include "../../pngpriv.h" |
|
|
|
#include "sRGB.h" |
|
|
|
/* The tables are declared 'const' in pngpriv.h, so this redefines the tables to |
|
* be used. |
|
*/ |
|
#define png_sRGB_table sRGB_table |
|
#define png_sRGB_base sRGB_base |
|
#define png_sRGB_delta sRGB_delta |
|
|
|
static png_uint_16 png_sRGB_table[256]; |
|
static png_uint_16 png_sRGB_base[512]; |
|
static png_byte png_sRGB_delta[512]; |
|
|
|
static const unsigned int max_input = 255*65535; |
|
|
|
double |
|
fsRGB(double l) |
|
{ |
|
return sRGB_from_linear(l/max_input); |
|
} |
|
|
|
double |
|
sRGB(unsigned int i) |
|
{ |
|
return fsRGB(i); |
|
} |
|
|
|
double |
|
finvsRGB(unsigned int i) |
|
{ |
|
return 65535 * linear_from_sRGB(i/255.); |
|
} |
|
|
|
png_uint_16 |
|
invsRGB(unsigned int i) |
|
{ |
|
unsigned int x = nearbyint(finvsRGB(i)); |
|
|
|
if (x > 65535) |
|
{ |
|
fprintf(stderr, "invsRGB(%u) overflows to %u\n", i, x); |
|
exit(1); |
|
} |
|
|
|
return (png_uint_16)x; |
|
} |
|
|
|
int |
|
main(int argc, char **argv) |
|
{ |
|
unsigned int i, i16, ibase; |
|
double min_error = 0; |
|
double max_error = 0; |
|
double min_error16 = 0; |
|
double max_error16 = 0; |
|
double adjust; |
|
double adjust_lo = 0.4, adjust_hi = 0.6, adjust_mid = 0.5; |
|
unsigned int ec_lo = 0, ec_hi = 0, ec_mid = 0; |
|
unsigned int error_count = 0; |
|
unsigned int error_count16 = 0; |
|
int test_only = 0; |
|
|
|
if (argc > 1) |
|
test_only = strcmp("--test", argv[1]) == 0; |
|
|
|
/* Initialize the encoding table first. */ |
|
for (i=0; i<256; ++i) |
|
{ |
|
png_sRGB_table[i] = invsRGB(i); |
|
} |
|
|
|
/* Now work out the decoding tables (this is where the error comes in because |
|
* there are 512 set points and 512 straight lines between them.) |
|
*/ |
|
for (;;) |
|
{ |
|
if (ec_lo == 0) |
|
adjust = adjust_lo; |
|
|
|
else if (ec_hi == 0) |
|
adjust = adjust_hi; |
|
|
|
else if (ec_mid == 0) |
|
adjust = adjust_mid; |
|
|
|
else if (ec_mid < ec_hi) |
|
adjust = (adjust_mid + adjust_hi)/2; |
|
|
|
else if (ec_mid < ec_lo) |
|
adjust = (adjust_mid + adjust_lo)/2; |
|
|
|
else |
|
{ |
|
fprintf(stderr, "not reached: %u .. %u .. %u\n", ec_lo, ec_mid, ec_hi); |
|
exit(1); |
|
} |
|
|
|
/* Calculate the table using the current 'adjust' */ |
|
for (i=0; i<=511; ++i) |
|
{ |
|
double lo = 255 * sRGB(i << 15); |
|
double hi = 255 * sRGB((i+1) << 15); |
|
unsigned int calc; |
|
|
|
calc = nearbyint((lo+adjust) * 256); |
|
if (calc > 65535) |
|
{ |
|
fprintf(stderr, "table[%d][0]: overflow %08x (%d)\n", i, calc, |
|
calc); |
|
exit(1); |
|
} |
|
png_sRGB_base[i] = calc; |
|
|
|
calc = nearbyint((hi-lo) * 32); |
|
if (calc > 255) |
|
{ |
|
fprintf(stderr, "table[%d][1]: overflow %08x (%d)\n", i, calc, |
|
calc); |
|
exit(1); |
|
} |
|
png_sRGB_delta[i] = calc; |
|
} |
|
|
|
/* Check the 16-bit linear values alone: */ |
|
error_count16 = 0; |
|
for (i16=0; i16 <= 65535; ++i16) |
|
{ |
|
unsigned int i = 255*i16; |
|
unsigned int iexact = nearbyint(255*sRGB(i)); |
|
unsigned int icalc = PNG_sRGB_FROM_LINEAR(i); |
|
|
|
if (icalc != iexact) |
|
++error_count16; |
|
} |
|
|
|
/* Now try changing the adjustment. */ |
|
if (ec_lo == 0) |
|
ec_lo = error_count16; |
|
|
|
else if (ec_hi == 0) |
|
ec_hi = error_count16; |
|
|
|
else if (ec_mid == 0) |
|
{ |
|
ec_mid = error_count16; |
|
printf("/* initial error counts: %u .. %u .. %u */\n", ec_lo, ec_mid, |
|
ec_hi); |
|
} |
|
|
|
else if (error_count16 < ec_mid) |
|
{ |
|
printf("/* adjust (mid ): %f: %u -> %u */\n", adjust, ec_mid, |
|
error_count16); |
|
ec_mid = error_count16; |
|
adjust_mid = adjust; |
|
} |
|
|
|
else if (adjust < adjust_mid && error_count16 < ec_lo) |
|
{ |
|
printf("/* adjust (low ): %f: %u -> %u */\n", adjust, ec_lo, |
|
error_count16); |
|
ec_lo = error_count16; |
|
adjust_lo = adjust; |
|
} |
|
|
|
else if (adjust > adjust_mid && error_count16 < ec_hi) |
|
{ |
|
printf("/* adjust (high): %f: %u -> %u */\n", adjust, ec_hi, |
|
error_count16); |
|
ec_hi = error_count16; |
|
adjust_hi = adjust; |
|
} |
|
|
|
else |
|
{ |
|
adjust = adjust_mid; |
|
printf("/* adjust: %f: %u */\n", adjust, ec_mid); |
|
break; |
|
} |
|
} |
|
|
|
/* For each entry in the table try to adjust it to minimize the error count |
|
* in that entry. Each entry corresponds to 128 input values. |
|
*/ |
|
for (ibase=0; ibase<65536; ibase+=128) |
|
{ |
|
png_uint_16 base = png_sRGB_base[ibase >> 7], trybase = base, ob=base; |
|
png_byte delta = png_sRGB_delta[ibase >> 7], trydelta = delta, od=delta; |
|
unsigned int ecbase = 0, eco; |
|
|
|
for (;;) |
|
{ |
|
png_sRGB_base[ibase >> 7] = trybase; |
|
png_sRGB_delta[ibase >> 7] = trydelta; |
|
|
|
/* Check the 16-bit linear values alone: */ |
|
error_count16 = 0; |
|
for (i16=ibase; i16 < ibase+128; ++i16) |
|
{ |
|
unsigned int i = 255*i16; |
|
unsigned int iexact = nearbyint(255*sRGB(i)); |
|
unsigned int icalc = PNG_sRGB_FROM_LINEAR(i); |
|
|
|
if (icalc != iexact) |
|
++error_count16; |
|
} |
|
|
|
if (error_count16 == 0) |
|
break; |
|
|
|
if (ecbase == 0) |
|
{ |
|
eco = ecbase = error_count16; |
|
++trybase; /* First test */ |
|
} |
|
|
|
else if (error_count16 < ecbase) |
|
{ |
|
if (trybase > base) |
|
{ |
|
base = trybase; |
|
++trybase; |
|
} |
|
else if (trybase < base) |
|
{ |
|
base = trybase; |
|
--trybase; |
|
} |
|
else if (trydelta > delta) |
|
{ |
|
delta = trydelta; |
|
++trydelta; |
|
} |
|
else if (trydelta < delta) |
|
{ |
|
delta = trydelta; |
|
--trydelta; |
|
} |
|
else |
|
{ |
|
fprintf(stderr, "makesRGB: impossible\n"); |
|
exit(1); |
|
} |
|
ecbase = error_count16; |
|
} |
|
|
|
else |
|
{ |
|
if (trybase > base) |
|
trybase = base-1; |
|
else if (trybase < base) |
|
{ |
|
trybase = base; |
|
++trydelta; |
|
} |
|
else if (trydelta > delta) |
|
trydelta = delta-1; |
|
else if (trydelta < delta) |
|
break; /* end of tests */ |
|
} |
|
} |
|
|
|
png_sRGB_base[ibase >> 7] = base; |
|
png_sRGB_delta[ibase >> 7] = delta; |
|
if (base != ob || delta != od) |
|
{ |
|
printf("/* table[%u]={%u,%u} -> {%u,%u} %u -> %u errors */\n", |
|
ibase>>7, ob, od, base, delta, eco, ecbase); |
|
} |
|
else if (0) |
|
printf("/* table[%u]={%u,%u} %u errors */\n", ibase>>7, ob, od, |
|
ecbase); |
|
} |
|
|
|
/* Only do the full (slow) test at the end: */ |
|
min_error = -.4999; |
|
max_error = .4999; |
|
error_count = 0; |
|
|
|
for (i=0; i <= max_input; ++i) |
|
{ |
|
unsigned int iexact = nearbyint(255*sRGB(i)); |
|
unsigned int icalc = PNG_sRGB_FROM_LINEAR(i); |
|
|
|
if (icalc != iexact) |
|
{ |
|
double err = 255*sRGB(i) - icalc; |
|
|
|
if (err > (max_error+.001) || err < (min_error-.001)) |
|
{ |
|
printf( |
|
"/* 0x%08x: exact: %3d, got: %3d [tables: %08x, %08x] (%f) */\n", |
|
i, iexact, icalc, png_sRGB_base[i>>15], |
|
png_sRGB_delta[i>>15], err); |
|
} |
|
|
|
++error_count; |
|
if (err > max_error) |
|
max_error = err; |
|
else if (err < min_error) |
|
min_error = err; |
|
} |
|
} |
|
|
|
/* Re-check the 16-bit cases too, including the warning if there is an error |
|
* bigger than 1. |
|
*/ |
|
error_count16 = 0; |
|
max_error16 = 0; |
|
min_error16 = 0; |
|
for (i16=0; i16 <= 65535; ++i16) |
|
{ |
|
unsigned int i = 255*i16; |
|
unsigned int iexact = nearbyint(255*sRGB(i)); |
|
unsigned int icalc = PNG_sRGB_FROM_LINEAR(i); |
|
|
|
if (icalc != iexact) |
|
{ |
|
double err = 255*sRGB(i) - icalc; |
|
|
|
++error_count16; |
|
if (err > max_error16) |
|
max_error16 = err; |
|
else if (err < min_error16) |
|
min_error16 = err; |
|
|
|
if (abs(icalc - iexact) > 1) |
|
printf( |
|
"/* 0x%04x: exact: %3d, got: %3d [tables: %08x, %08x] (%f) */\n", |
|
i16, iexact, icalc, png_sRGB_base[i>>15], |
|
png_sRGB_delta[i>>15], err); |
|
} |
|
} |
|
|
|
/* Check the round trip for each 8-bit sRGB value. */ |
|
for (i16=0; i16 <= 255; ++i16) |
|
{ |
|
unsigned int i = 255 * png_sRGB_table[i16]; |
|
unsigned int iexact = nearbyint(255*sRGB(i)); |
|
unsigned int icalc = PNG_sRGB_FROM_LINEAR(i); |
|
|
|
if (i16 != iexact) |
|
{ |
|
fprintf(stderr, "8-bit rounding error: %d -> %d\n", i16, iexact); |
|
exit(1); |
|
} |
|
|
|
if (icalc != i16) |
|
{ |
|
double finv = finvsRGB(i16); |
|
|
|
printf("/* 8-bit roundtrip error: %d -> %f -> %d(%f) */\n", |
|
i16, finv, icalc, fsRGB(255*finv)); |
|
} |
|
} |
|
|
|
|
|
printf("/* error: %g - %g, %u (%g%%) of readings inexact */\n", |
|
min_error, max_error, error_count, (100.*error_count)/max_input); |
|
printf("/* 16-bit error: %g - %g, %u (%g%%) of readings inexact */\n", |
|
min_error16, max_error16, error_count16, (100.*error_count16)/65535); |
|
|
|
if (!test_only) |
|
{ |
|
printf("const png_uint_16 png_sRGB_table[256] =\n{\n "); |
|
for (i=0; i<255; ) |
|
{ |
|
do |
|
{ |
|
printf("%d,", png_sRGB_table[i++]); |
|
} |
|
while ((i & 0x7) != 0 && i<255); |
|
if (i<255) printf("\n "); |
|
} |
|
printf("%d\n};\n\n", png_sRGB_table[i]); |
|
|
|
|
|
printf("const png_uint_16 png_sRGB_base[512] =\n{\n "); |
|
for (i=0; i<511; ) |
|
{ |
|
do |
|
{ |
|
printf("%d,", png_sRGB_base[i++]); |
|
} |
|
while ((i & 0x7) != 0 && i<511); |
|
if (i<511) printf("\n "); |
|
} |
|
printf("%d\n};\n\n", png_sRGB_base[i]); |
|
|
|
printf("const png_byte png_sRGB_delta[512] =\n{\n "); |
|
for (i=0; i<511; ) |
|
{ |
|
do |
|
{ |
|
printf("%d,", png_sRGB_delta[i++]); |
|
} |
|
while ((i & 0xf) != 0 && i<511); |
|
if (i<511) printf("\n "); |
|
} |
|
printf("%d\n};\n\n", png_sRGB_delta[i]); |
|
} |
|
|
|
return 0; |
|
}
|
|
|