workbench/libs/png/contrib/tools/makesRGB.c

   1 /* makesRGB.c -- build sRGB-to-linear and linear-to-sRGB conversion tables
   2  *
   3  * Last changed in libpng 1.6.0 [February 14, 2013]
   4  *
   5  * COPYRIGHT: Written by John Cunningham Bowler, 2013.
   6  * To the extent possible under law, the author has waived all copyright and
   7  * related or neighboring rights to this work.  This work is published from:
   8  * United States.
   9  *
  10  * Make a table to convert 8-bit sRGB encoding values into the closest 16-bit
  11  * linear value.
  12  *
  13  * Make two tables to take a linear value scaled to 255*65535 and return an
  14  * approximation to the 8-bit sRGB encoded value.  Calculate the error in these
  15  * tables and display it.
  16  */
  17 #define _C99_SOURCE 1
  18 #include <stdio.h>
  19 #include <math.h>
  20 #include <stdlib.h>
  21
  22 /* pngpriv.h includes the definition of 'PNG_sRGB_FROM_LINEAR' which is required
  23  * to verify the actual code.
  24  */
  25 #include "../../pngpriv.h"
  26
  27 #include "sRGB.h"
  28
  29 /* The tables are declared 'const' in pngpriv.h, so this redefines the tables to
  30  * be used.
  31  */
  32 #define png_sRGB_table sRGB_table
  33 #define png_sRGB_base sRGB_base
  34 #define png_sRGB_delta sRGB_delta
  35
  36 static png_uint_16 png_sRGB_table[256];
  37 static png_uint_16 png_sRGB_base[512];
  38 static png_byte png_sRGB_delta[512];
  39
  40 static const unsigned int max_input = 255*65535;
  41
  42 double
  43 fsRGB(double l)
  44 {
  45    return sRGB_from_linear(l/max_input);
  46 }
  47
  48 double
  49 sRGB(unsigned int i)
  50 {
  51    return fsRGB(i);
  52 }
  53
  54 double
  55 finvsRGB(unsigned int i)
  56 {
  57    return 65535 * linear_from_sRGB(i/255.);
  58 }
  59
  60 png_uint_16
  61 invsRGB(unsigned int i)
  62 {
  63    unsigned int x = nearbyint(finvsRGB(i));
  64
  65    if (x > 65535)
  66    {
  67       fprintf(stderr, "invsRGB(%u) overflows to %u\n", i, x);
  68       exit(1);
  69    }
  70
  71    return (png_uint_16)x;
  72 }
  73
  74 int
  75 main(int argc, char **argv)
  76 {
  77    unsigned int i, i16, ibase;
  78    double min_error = 0;
  79    double max_error = 0;
  80    double min_error16 = 0;
  81    double max_error16 = 0;
  82    double adjust;
  83    double adjust_lo = 0.4, adjust_hi = 0.6, adjust_mid = 0.5;
  84    unsigned int ec_lo = 0, ec_hi = 0, ec_mid = 0;
  85    unsigned int error_count = 0;
  86    unsigned int error_count16 = 0;
  87    int test_only = 0;
  88
  89    if (argc > 1)
  90       test_only = strcmp("--test", argv[1]) == 0;
  91
  92    /* Initialize the encoding table first. */
  93    for (i=0; i<256; ++i)
  94    {
  95       png_sRGB_table[i] = invsRGB(i);
  96    }
  97
  98    /* Now work out the decoding tables (this is where the error comes in because
  99     * there are 512 set points and 512 straight lines between them.)
 100     */
 101    for (;;)
 102    {
 103       if (ec_lo == 0)
 104          adjust = adjust_lo;
 105
 106       else if (ec_hi == 0)
 107          adjust = adjust_hi;
 108
 109       else if (ec_mid == 0)
 110          adjust = adjust_mid;
 111
 112       else if (ec_mid < ec_hi)
 113          adjust = (adjust_mid + adjust_hi)/2;
 114
 115       else if (ec_mid < ec_lo)
 116          adjust = (adjust_mid + adjust_lo)/2;
 117
 118       else
 119       {
 120          fprintf(stderr, "not reached: %u .. %u .. %u\n", ec_lo, ec_mid, ec_hi);
 121          exit(1);
 122       }
 123
 124       /* Calculate the table using the current 'adjust' */
 125       for (i=0; i<=511; ++i)
 126       {
 127          double lo = 255 * sRGB(i << 15);
 128          double hi = 255 * sRGB((i+1) << 15);
 129          unsigned int calc;
 130
 131          calc = nearbyint((lo+adjust) * 256);
 132          if (calc > 65535)
 133          {
 134             fprintf(stderr, "table[%d][0]: overflow %08x (%d)\n", i, calc,
 135                calc);
 136             exit(1);
 137          }
 138          png_sRGB_base[i] = calc;
 139
 140          calc = nearbyint((hi-lo) * 32);
 141          if (calc > 255)
 142          {
 143             fprintf(stderr, "table[%d][1]: overflow %08x (%d)\n", i, calc,
 144                calc);
 145             exit(1);
 146          }
 147          png_sRGB_delta[i] = calc;
 148       }
 149
 150       /* Check the 16-bit linear values alone: */
 151       error_count16 = 0;
 152       for (i16=0; i16 <= 65535; ++i16)
 153       {
 154          unsigned int i = 255*i16;
 155          unsigned int iexact = nearbyint(255*sRGB(i));
 156          unsigned int icalc = PNG_sRGB_FROM_LINEAR(i);
 157
 158          if (icalc != iexact)
 159             ++error_count16;
 160       }
 161
 162       /* Now try changing the adjustment. */
 163       if (ec_lo == 0)
 164          ec_lo = error_count16;
 165
 166       else if (ec_hi == 0)
 167          ec_hi = error_count16;
 168
 169       else if (ec_mid == 0)
 170       {
 171          ec_mid = error_count16;
 172          printf("/* initial error counts: %u .. %u .. %u */\n", ec_lo, ec_mid,
 173             ec_hi);
 174       }
 175
 176       else if (error_count16 < ec_mid)
 177       {
 178          printf("/* adjust (mid ): %f: %u -> %u */\n", adjust, ec_mid,
 179             error_count16);
 180          ec_mid = error_count16;
 181          adjust_mid = adjust;
 182       }
 183
 184       else if (adjust < adjust_mid && error_count16 < ec_lo)
 185       {
 186          printf("/* adjust (low ): %f: %u -> %u */\n", adjust, ec_lo,
 187             error_count16);
 188          ec_lo = error_count16;
 189          adjust_lo = adjust;
 190       }
 191
 192       else if (adjust > adjust_mid && error_count16 < ec_hi)
 193       {
 194          printf("/* adjust (high): %f: %u -> %u */\n", adjust, ec_hi,
 195             error_count16);
 196          ec_hi = error_count16;
 197          adjust_hi = adjust;
 198       }
 199
 200       else
 201       {
 202          adjust = adjust_mid;
 203          printf("/* adjust: %f: %u */\n", adjust, ec_mid);
 204          break;
 205       }
 206    }
 207
 208    /* For each entry in the table try to adjust it to minimize the error count
 209     * in that entry.  Each entry corresponds to 128 input values.
 210     */
 211    for (ibase=0; ibase<65536; ibase+=128)
 212    {
 213       png_uint_16 base = png_sRGB_base[ibase >> 7], trybase = base, ob=base;
 214       png_byte delta = png_sRGB_delta[ibase >> 7], trydelta = delta, od=delta;
 215       unsigned int ecbase = 0, eco;
 216
 217       for (;;)
 218       {
 219          png_sRGB_base[ibase >> 7] = trybase;
 220          png_sRGB_delta[ibase >> 7] = trydelta;
 221
 222          /* Check the 16-bit linear values alone: */
 223          error_count16 = 0;
 224          for (i16=ibase; i16 < ibase+128; ++i16)
 225          {
 226             unsigned int i = 255*i16;
 227             unsigned int iexact = nearbyint(255*sRGB(i));
 228             unsigned int icalc = PNG_sRGB_FROM_LINEAR(i);
 229
 230             if (icalc != iexact)
 231                ++error_count16;
 232          }
 233
 234          if (error_count16 == 0)
 235             break;
 236
 237          if (ecbase == 0)
 238          {
 239             eco = ecbase = error_count16;
 240             ++trybase; /* First test */
 241          }
 242
 243          else if (error_count16 < ecbase)
 244          {
 245             if (trybase > base)
 246             {
 247                base = trybase;
 248                ++trybase;
 249             }
 250             else if (trybase < base)
 251             {
 252                base = trybase;
 253                --trybase;
 254             }
 255             else if (trydelta > delta)
 256             {
 257                delta = trydelta;
 258                ++trydelta;
 259             }
 260             else if (trydelta < delta)
 261             {
 262                delta = trydelta;
 263                --trydelta;
 264             }
 265             else
 266             {
 267                fprintf(stderr, "makesRGB: impossible\n");
 268                exit(1);
 269             }
 270             ecbase = error_count16;
 271          }
 272
 273          else
 274          {
 275             if (trybase > base)
 276                trybase = base-1;
 277             else if (trybase < base)
 278             {
 279                trybase = base;
 280                ++trydelta;
 281             }
 282             else if (trydelta > delta)
 283                trydelta = delta-1;
 284             else if (trydelta < delta)
 285                break; /* end of tests */
 286          }
 287       }
 288
 289       png_sRGB_base[ibase >> 7] = base;
 290       png_sRGB_delta[ibase >> 7] = delta;
 291       if (base != ob || delta != od)
 292       {
 293          printf("/* table[%u]={%u,%u} -> {%u,%u} %u -> %u errors */\n",
 294             ibase>>7, ob, od, base, delta, eco, ecbase);
 295       }
 296       else if (0)
 297          printf("/* table[%u]={%u,%u} %u errors */\n", ibase>>7, ob, od,
 298             ecbase);
 299    }
 300
 301    /* Only do the full (slow) test at the end: */
 302    min_error = -.4999;
 303    max_error = .4999;
 304    error_count = 0;
 305
 306    for (i=0; i <= max_input; ++i)
 307    {
 308       unsigned int iexact = nearbyint(255*sRGB(i));
 309       unsigned int icalc = PNG_sRGB_FROM_LINEAR(i);
 310
 311       if (icalc != iexact)
 312       {
 313          double err = 255*sRGB(i) - icalc;
 314
 315          if (err > (max_error+.001) || err < (min_error-.001))
 316          {
 317             printf(
 318                "/* 0x%08x: exact: %3d, got: %3d [tables: %08x, %08x] (%f) */\n",
 319                i, iexact, icalc, png_sRGB_base[i>>15],
 320                png_sRGB_delta[i>>15], err);
 321          }
 322
 323          ++error_count;
 324          if (err > max_error)
 325             max_error = err;
 326          else if (err < min_error)
 327             min_error = err;
 328       }
 329    }
 330
 331    /* Re-check the 16-bit cases too, including the warning if there is an error
 332     * bigger than 1.
 333     */
 334    error_count16 = 0;
 335    max_error16 = 0;
 336    min_error16 = 0;
 337    for (i16=0; i16 <= 65535; ++i16)
 338    {
 339       unsigned int i = 255*i16;
 340       unsigned int iexact = nearbyint(255*sRGB(i));
 341       unsigned int icalc = PNG_sRGB_FROM_LINEAR(i);
 342
 343       if (icalc != iexact)
 344       {
 345          double err = 255*sRGB(i) - icalc;
 346
 347          ++error_count16;
 348          if (err > max_error16)
 349             max_error16 = err;
 350          else if (err < min_error16)
 351             min_error16 = err;
 352
 353          if (abs(icalc - iexact) > 1)
 354             printf(
 355                "/* 0x%04x: exact: %3d, got: %3d [tables: %08x, %08x] (%f) */\n",
 356                i16, iexact, icalc, png_sRGB_base[i>>15],
 357                png_sRGB_delta[i>>15], err);
 358       }
 359    }
 360
 361    /* Check the round trip for each 8-bit sRGB value. */
 362    for (i16=0; i16 <= 255; ++i16)
 363    {
 364       unsigned int i = 255 * png_sRGB_table[i16];
 365       unsigned int iexact = nearbyint(255*sRGB(i));
 366       unsigned int icalc = PNG_sRGB_FROM_LINEAR(i);
 367
 368       if (i16 != iexact)
 369       {
 370          fprintf(stderr, "8-bit rounding error: %d -> %d\n", i16, iexact);
 371          exit(1);
 372       }
 373
 374       if (icalc != i16)
 375       {
 376          double finv = finvsRGB(i16);
 377
 378          printf("/* 8-bit roundtrip error: %d -> %f -> %d(%f) */\n",
 379             i16, finv, icalc, fsRGB(255*finv));
 380       }
 381    }
 382
 383
 384    printf("/* error: %g - %g, %u (%g%%) of readings inexact */\n",
 385       min_error, max_error, error_count, (100.*error_count)/max_input);
 386    printf("/* 16-bit error: %g - %g, %u (%g%%) of readings inexact */\n",
 387       min_error16, max_error16, error_count16, (100.*error_count16)/65535);
 388
 389    if (!test_only)
 390    {
 391       printf("PNG_CONST png_uint_16 png_sRGB_table[256] =\n{\n   ");
 392       for (i=0; i<255; )
 393       {
 394          do
 395          {
 396             printf("%d,", png_sRGB_table[i++]);
 397          }
 398          while ((i & 0x7) != 0 && i<255);
 399          if (i<255) printf("\n   ");
 400       }
 401       printf("%d\n};\n\n", png_sRGB_table[i]);
 402
 403
 404       printf("PNG_CONST png_uint_16 png_sRGB_base[512] =\n{\n   ");
 405       for (i=0; i<511; )
 406       {
 407          do
 408          {
 409             printf("%d,", png_sRGB_base[i++]);
 410          }
 411          while ((i & 0x7) != 0 && i<511);
 412          if (i<511) printf("\n   ");
 413       }
 414       printf("%d\n};\n\n", png_sRGB_base[i]);
 415
 416       printf("PNG_CONST png_byte png_sRGB_delta[512] =\n{\n   ");
 417       for (i=0; i<511; )
 418       {
 419          do
 420          {
 421             printf("%d,", png_sRGB_delta[i++]);
 422          }
 423          while ((i & 0xf) != 0 && i<511);
 424          if (i<511) printf("\n   ");
 425       }
 426       printf("%d\n};\n\n", png_sRGB_delta[i]);
 427    }
 428
 429    return 0;
 430 }