kc3-lang/libpng/contrib/tools/makesRGB.c

Branch - branch -libpng16libpng17

• Show log

  Commit

• Hash : 77c3a392
  Author :
  Date : 2022-11-20T21:23:33
  

  Clean up comments and whitespace characters in source files
  
  Remove all remaining "last changed" version info from source comments.
  (The version control system maintains this information automatically.)
  
  Delete the trailing whitespace characters.
  

Download

• contrib/tools/makesRGB.c

• /* makesRGB.c -- build sRGB-to-linear and linear-to-sRGB conversion tables
   *
   * 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;
  }
  

Download