[Feature][ZXW-88]merge P50 version
Only Configure: No
Affected branch: master
Affected module: unknown
Is it affected on both ZXIC and MTK: only ZXIC
Self-test: Yes
Doc Update: No
Change-Id: I34667719d9e0e7e29e8e4368848601cde0a48408
diff --git a/ap/lib/libpng/libpng-1.6.37/contrib/tools/makesRGB.c b/ap/lib/libpng/libpng-1.6.37/contrib/tools/makesRGB.c
new file mode 100755
index 0000000..d0c0ca9
--- /dev/null
+++ b/ap/lib/libpng/libpng-1.6.37/contrib/tools/makesRGB.c
@@ -0,0 +1,430 @@
+/* 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;
+}