Reland: [qcms] Fix build_output_lut to return correct data for parametric curves

third_party/qcms/src/tests/qcms_test_output_trc.c

+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the Chromium LICENSE file.
+
+#include "qcms.h"
+#include "qcms_test_util.h"
+
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+#define PARAMETRIC_CURVE_TYPE    0x70617261 // 'para'
+#define MAX_FLOAT_ERROR    0.000001f
+
+static const float inverse65535 = (float) (1.0 / 65535.0);
+
+extern float clamp_float(float a);
+
+static int get_output_gamma_table(const char *profile_path, uint16_t **table, size_t *size, bool precache)
+{
+    qcms_transform *transform;
+    qcms_profile *sRGB;
+    qcms_profile *target;
+
+    target = qcms_profile_from_path(profile_path);
+    if (!target) {
+        fprintf(stderr, "Invalid input profile\n");
+        return EXIT_FAILURE;
+    }
+
+    if (precache) {

[Noel Gordon, 2016/04/21 06:01:53]

Why is the precache relevant to this test?  The curve we extract is created and
lives inside the transform struct, which is independent of pre-caching best I
can tell.

[radu.velea, 2016/04/21 07:13:45]

Yes, but the same calculations are done during precache stage. Maybe in the
future we'll save them somewhere so we don't have to do it twice. I just thought
that regardless how the 2 code paths evolve it would be nice to check for
consistency. If you think it is redundant I can remove it.

+        qcms_profile_precache_output_transform(target);
+    }
+
+    sRGB = qcms_profile_sRGB();
+
+    transform = qcms_transform_create(sRGB, QCMS_DATA_RGBA_8, target, QCMS_DATA_RGBA_8, QCMS_INTENT_DEFAULT);
+    if (!transform) {
+        fprintf(stderr, "Failed to create colour transform\n");
+        qcms_profile_release(sRGB);
+        qcms_profile_release(target);
+        return EXIT_FAILURE;
+    }
+
+    *size = qcms_transform_get_output_trc_rgba(transform, target, QCMS_TRC_USHORT, NULL);
+    *table = malloc(*size * sizeof(uint16_t) * 4);
+    qcms_transform_get_output_trc_rgba(transform, target, QCMS_TRC_USHORT, *table);
+
+    qcms_transform_release(transform);
+
+    qcms_profile_release(sRGB);
+    qcms_profile_release(target);
+
+    return 0;
+}
+
+static int get_input_gamma_table(const char *profile_path, uint16_t **table, size_t expected_size)
+{
+    qcms_transform *transform;
+    qcms_profile *source;
+    qcms_profile *sRGB;
+    size_t size;
+
+    source = qcms_profile_from_path(profile_path);
+    if (!source) {
+        fprintf(stderr, "Invalid input profile\n");
+        return EXIT_FAILURE;
+    }
+
+    sRGB = qcms_profile_sRGB();
+
+    transform = qcms_transform_create(source, QCMS_DATA_RGBA_8, sRGB, QCMS_DATA_RGBA_8, QCMS_INTENT_DEFAULT);
+    if (!transform) {
+        fprintf(stderr, "Failed to create colour transform\n");
+        qcms_profile_release(sRGB);
+        qcms_profile_release(source);
+        return EXIT_FAILURE;
+    }
+
+    // For now the size of input gamma table for parametric curves is hardcoded to 256.
+    // See compute_curve_gamma_table_type_parametric for details.
+    // Future implementations might decide to return an arbitrary-sized table.
+    size = qcms_transform_get_input_trc_rgba(transform, source, QCMS_TRC_USHORT, NULL);
+    if (size != expected_size) {
+        fprintf(stderr, "Expected input table size (%zu) to match output size (%zu)\n", size, expected_size);
+        size = size > expected_size ? size : expected_size;
+    }
+
+    *table = calloc(size, sizeof(uint16_t) * 4);
+    qcms_transform_get_input_trc_rgba(transform, source, QCMS_TRC_USHORT, *table);
+
+    qcms_transform_release(transform);
+
+    qcms_profile_release(sRGB);
+    qcms_profile_release(source);
+
+    return 0;
+}
+
+static int qcms_test_output_trc(size_t width,
+        size_t height,
+        int iterations,
+        const char *in_path,
+        const char *out_path,
+        const int force_software)
+{
+    int err = 0;
+    qcms_profile *profile;
+    uint16_t *gamma_table_out, *gamma_table_out_precache;
+    size_t gamma_table_size, gamma_table_size_precache;
+    int i;
+
+    printf("Test qcms output gamma curve integrity with and without precached tables.\n");
+
+    if (!in_path) {
+        fprintf(stderr, "%s: please provide valid ICC profiles via -i option\n", __FUNCTION__);
+        return EXIT_FAILURE;
+    }
+
+    // Create profiles and transforms, get table and then free resources to make sure none
+    // of the internal tables are initialized by previous calls.
+    gamma_table_out = NULL;
+    gamma_table_size = 0;
+    if (get_output_gamma_table(in_path, &gamma_table_out, &gamma_table_size, true) != 0) {

[Noel Gordon, 2016/04/21 06:01:53]

true => precache, but the results are stored in gamma_table_* ...

[radu.velea, 2016/04/21 07:13:45]

See comment above.

+        fprintf(stderr, "Unable to extract output gamma table\n");
+        return EXIT_FAILURE;
+    }
+
+    gamma_table_out_precache = NULL;
+    gamma_table_size_precache = 0;
+    if (get_output_gamma_table(in_path, &gamma_table_out_precache, &gamma_table_size_precache, false) != 0) {

[Noel Gordon, 2016/04/21 06:01:53]

... false => no pre-cache but the results are stored in gamma_table_*_precache 
vars., (which is a little confusing) ...

[radu.velea, 2016/04/21 07:13:45]

Same as above.

+        fprintf(stderr, "Unable to extract precached output gamma table\n");
+        return EXIT_FAILURE;
+    }
+
+    // Check if precached and non-precached tables match in size and contents.
+    if (gamma_table_size != gamma_table_size_precache) {

[Noel Gordon, 2016/04/21 06:01:53]

but as mentioned above, why do the precache vs non-precache cases need to be
separately tested.

[radu.velea, 2016/04/26 10:23:18]

Done.

+        fprintf(stderr, "Size mismatch between output table sizes.\n"
+                "Output gamma size = %zu, gamma size with precahce = %zu\n", gamma_table_size, gamma_table_size_precache);
+        free(gamma_table_out);
+        free(gamma_table_out_precache);
+        return EXIT_FAILURE;
+    }
+
+    printf("LUT size = %zu, %zu\n", gamma_table_size, gamma_table_size_precache);
+
+    for (i = 0; i < 4 * gamma_table_size; ++i) {
+        err += abs(gamma_table_out[i] - gamma_table_out_precache[i]);
+    }
+
+    if (err != 0) {
+        fprintf(stderr, "Gamma output total error = %d\n.Aborting.", err);
+        free(gamma_table_out);
+        free(gamma_table_out_precache);
+        return EXIT_FAILURE;
+    }
+
+    profile = qcms_profile_from_path(in_path);
+    if (!profile) {
+        fprintf(stderr, "Invalid input profile\n");
+        free(gamma_table_out);
+        free(gamma_table_out_precache);
+        return EXIT_FAILURE;
+    }
+
+    // Check only for red curve for now.
+    if (profile->redTRC->type == PARAMETRIC_CURVE_TYPE) {
+        int type = - (profile->redTRC->count + 1);
+        FILE *gamma_file;
+        uint16_t *gamma_table_in = NULL;
+        uint16_t *p_table_out, *p_table_in;
+        double gamma_aprox_in = 0, gamma_aprox_out = 0;
+        double sum_of_sqares = 0;
+        char file_name[256] = {0,};
+
+        printf("Detected parametric curve type = %d\n", profile->redTRC->count);
+
+        sprintf(file_name, "qcms-test-%ld-parametric-gamma-%s.csv", (long int)time(NULL), profile->description);
+        printf("Writing input and output gamma tables to %s\n", file_name);
+
+        printf("gamma = %.6f, a = %.6f, b = %.6f, c = %.6f, d = %.6f, e = %.6f, f = %.6f\n",
+                profile->redTRC->parameter[0], profile->redTRC->parameter[1], profile->redTRC->parameter[2],
+                profile->redTRC->parameter[3], profile->redTRC->parameter[4], profile->redTRC->parameter[5],
+                profile->redTRC->parameter[6]);
+
+        // Write output to stdout and tables into a csv file.
+        gamma_file = fopen(file_name, "w");
+        fprintf(gamma_file, "Parametric gamma values for %s\n", profile->description);
+        fprintf(gamma_file, "gamma, a, b, c, d, e, f\n");
+        fprintf(gamma_file, "%.6f, %.6f, %.6f, %.6f, %.6f, %.6f, %.6f\n",
+                profile->redTRC->parameter[0], profile->redTRC->parameter[1], profile->redTRC->parameter[2],
+                profile->redTRC->parameter[3], profile->redTRC->parameter[4], profile->redTRC->parameter[5],
+                profile->redTRC->parameter[6]);
+
+        get_input_gamma_table(in_path, &gamma_table_in, gamma_table_size);
+        if (!gamma_table_in) {
+            fprintf(stderr, "Unable to compute input trc. Aborting\n");
+            fclose(gamma_file);
+            qcms_profile_release(profile);
+            free(gamma_table_out);
+            free(gamma_table_out_precache);
+            return EXIT_FAILURE;
+        }
+
+        fprintf(gamma_file, "\n\nInput gamma, Output gamma, LCMS Output gamma, Output gamma error\n");
+
+        p_table_out = gamma_table_out;
+        p_table_in = gamma_table_in;
+
+        for (i = 0; i < gamma_table_size; ++i) {
+            float p = i / (gamma_table_size * 1.0);
+            float reference_out = clamp_float(evaluate_parametric_curve(type, profile->redTRC->parameter, p));
+            float actual_out = *p_table_out * inverse65535;
+            float error_out = fabs(actual_out - reference_out);
+            float input = *p_table_in * inverse65535;
+

[Noel Gordon, 2016/04/21 06:01:53]

I don't think the gamma estimator adds to the test, so on second thoughts, let's
remove it?

[radu.velea, 2016/04/21 07:13:45]

Ok.

+            // Approximate input and output gamma based on http://www.brucelindbloom.com/index.html?Eqn_BestGamma.html
+            if (p > MAX_FLOAT_ERROR && input > MAX_FLOAT_ERROR && actual_out > MAX_FLOAT_ERROR) {
+                gamma_aprox_in += log(p) * log(input);
+                gamma_aprox_out += log(p) * log(actual_out);
+                sum_of_sqares += log(p) * log(p);
+            }
+
+            fprintf(gamma_file, "%.6f, %.6f, %6f, %6f\n",input, actual_out, reference_out, error_out);
+
+            p_table_out += 4; // Skip other channels.
+            p_table_in += 4; // Skip other channels.
+        }
+
+        gamma_aprox_in /= sum_of_sqares;
+        gamma_aprox_out /= sum_of_sqares;
+
+        printf("Computed gamma from LUTs:\nInput = %.6lf\nOutput = %.6lf\nAccuracy? = %.6lf\n",
+                gamma_aprox_in, gamma_aprox_out, gamma_aprox_in * gamma_aprox_out);
+
+        free(gamma_table_in);
+        fclose(gamma_file);
+    }
+
+    qcms_profile_release(profile);
+
+    free(gamma_table_out);
+    free(gamma_table_out_precache);
+
+    return err;
+}
+
+struct qcms_test_case qcms_test_output_trc_info = {
+        "qcms_test_output_trc",
+        qcms_test_output_trc,
+        QCMS_TEST_DISABLED
+};