19765269522

Committed 28 Nov 2025 01:30PM UTC coverage: 39.983% (-1.6%) from 41.616%

Build # 19765269522

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #214 from saitoha/codex/add-logging-to-resize-processing

Limit scale logging and add timeline window controls

Run Details

9788 of 35562 branches covered (27.52%)

9 of 63 new or added lines in 1 file covered. (14.29%)

281 existing lines in 19 files now uncovered.

12991 of 32491 relevant lines covered (39.98%)

619662.16 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

8.06

/src/colorspace.c

/*
 * SPDX-License-Identifier: MIT
 *
 * Copyright (c) 2025 libsixel developers. See `AUTHORS`.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of
 * this software and associated documentation files (the "Software"), to deal in
 * the Software without restriction, including without limitation the rights to
 * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 * the Software, and to permit persons to whom the Software is furnished to do so,
 * subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
 * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

#include "config.h"

#include <math.h>
#include <stddef.h>

#include <sixel.h>

#include "colorspace.h"

#define SIXEL_COLORSPACE_LUT_SIZE 256
#define SIXEL_OKLAB_AB_OFFSET 0.5
#define SIXEL_OKLAB_AB_SCALE  255.0
#define SIXEL_CIELAB_AB_SCALE 128.0
#define SIXEL_CIELAB_L_SCALE  100.0
#define SIXEL_CIELAB_AB_LIMIT 1.5
#define SIXEL_DIN99D_L_SCALE  100.0
#define SIXEL_DIN99D_AB_RANGE 50.0

static const double sixel_linear_srgb_to_smptec_matrix[3][3] = {
    { 1.0651944799343782, -0.05539144537002962, -0.009975616485882548 },
    { -0.019633066659433226,  1.0363870284433383, -0.016731961783904975 },
    { 0.0016324889176928742,  0.004413466273704836,  0.994192644808602 }
};

static const double sixel_linear_smptec_to_srgb_matrix[3][3] = {
    { 0.9397048483892231,  0.05018036042570272,  0.010273409684415205 },
    { 0.01777536262173348, 0.9657705626655305,  0.01643197976410589 },
    { -0.0016219271954016755, -0.00436969856687614,  1.0057514450874723 }
};

static unsigned char gamma_to_linear_lut[SIXEL_COLORSPACE_LUT_SIZE];
static unsigned char linear_to_gamma_lut[SIXEL_COLORSPACE_LUT_SIZE];
static int tables_initialized = 0;

static inline double
sixel_clamp_unit(double value)
{
    if (value < 0.0) {
        return 0.0;
    }
    if (value > 1.0) {
        return 1.0;
    }
    return value;
}

static inline double
sixel_srgb_unit_to_linear(double value)
{
    double x;

    x = sixel_clamp_unit(value);
    if (x <= 0.04045) {
        return x / 12.92;
    }

    return pow((x + 0.055) / 1.055, 2.4);
}

static inline double
sixel_linear_to_srgb_unit(double value)
{
    double y;

    if (value <= 0.0) {
        return 0.0;
    }
    if (value >= 1.0) {
        return 1.0;
    }

    if (value <= 0.0031308) {
        y = value * 12.92;
    } else {
        y = 1.055 * pow(value, 1.0 / 2.4) - 0.055;
    }

    return sixel_clamp_unit(y);
}

static inline double
sixel_smptec_unit_to_linear(double value)
{
    double x;

    x = sixel_clamp_unit(value);
    if (x <= 0.0) {
        return 0.0;
    }
    if (x >= 1.0) {
        return 1.0;
    }

    return pow(x, 2.2);
}

static inline double
sixel_linear_to_smptec_unit(double value)
{
    double y;

    if (value <= 0.0) {
        return 0.0;
    }
    if (value >= 1.0) {
        return 1.0;
    }

    y = pow(value, 1.0 / 2.2);
    return sixel_clamp_unit(y);
}

static inline double
sixel_oklab_clamp_ab(double value)
{
    double lower;
    double upper;

    lower = -SIXEL_OKLAB_AB_OFFSET;
    upper = SIXEL_OKLAB_AB_OFFSET;
    if (value < lower) {
        return lower;
    }
    if (value > upper) {
        return upper;
    }

    return value;
}

static inline double
sixel_cielab_clamp_ab(double value)
{
    if (value < -SIXEL_CIELAB_AB_LIMIT) {
        return -SIXEL_CIELAB_AB_LIMIT;
    }
    if (value > SIXEL_CIELAB_AB_LIMIT) {
        return SIXEL_CIELAB_AB_LIMIT;
    }

    return value;
}

static inline double
sixel_din99d_clamp_ab_norm(double value)
{
    if (value < -1.0) {
        return -1.0;
    }
    if (value > 1.0) {
        return 1.0;
    }

    return value;
}

#if 0
static inline double
sixel_din99d_clamp_ab(double value)
{
    if (value < -SIXEL_DIN99D_AB_RANGE) {
        return -SIXEL_DIN99D_AB_RANGE;
    }
    if (value > SIXEL_DIN99D_AB_RANGE) {
        return SIXEL_DIN99D_AB_RANGE;
    }

    return value;
}
#endif

static unsigned char
sixel_colorspace_clamp(int value)
{
    if (value < 0) {
        return 0;
    }
    if (value > 255) {
        return 255;
    }
    return (unsigned char)value;
}

static inline double
sixel_srgb_to_linear_double(unsigned char v)
{
    double x = (double)v / 255.0;

    return sixel_srgb_unit_to_linear(x);
}

static inline unsigned char
sixel_linear_double_to_srgb(double v)
{
    double y;

    y = sixel_linear_to_srgb_unit(v);
    return sixel_colorspace_clamp((int)(y * 255.0 + 0.5));
}

static inline unsigned char
sixel_linear_double_to_byte(double v)
{
    if (v <= 0.0) {
        return 0;
    }
    if (v >= 1.0) {
        return 255;
    }

    return sixel_colorspace_clamp((int)(v * 255.0 + 0.5));
}

static inline double
sixel_smptec_to_linear_double(unsigned char v)
{
    double x = (double)v / 255.0;

    return sixel_smptec_unit_to_linear(x);
}

static inline unsigned char
sixel_linear_double_to_smptec(double v)
{
    double y;

    y = sixel_linear_to_smptec_unit(v);
    return sixel_colorspace_clamp((int)(y * 255.0 + 0.5));
}

static inline double
sixel_cielab_f(double t)
{
    double delta;

    delta = 6.0 / 29.0;
    if (t > delta * delta * delta) {
        return cbrt(t);
    }

    return (t / (3.0 * delta * delta)) + (4.0 / 29.0);
}

static inline double
sixel_cielab_f_inv(double t)
{
    double delta;

    delta = 6.0 / 29.0;
    if (t > delta) {
        return t * t * t;
    }

    return 3.0 * delta * delta * (t - (4.0 / 29.0));
}

static inline unsigned char
sixel_oklab_encode_L(double L)
{
    if (L < 0.0) {
        L = 0.0;
    } else if (L > 1.0) {
        L = 1.0;
    }

    return sixel_colorspace_clamp((int)(L * 255.0 + 0.5));
}

static inline unsigned char
sixel_oklab_encode_ab(double value)
{
    double encoded = value + SIXEL_OKLAB_AB_OFFSET;

    if (encoded < 0.0) {
        encoded = 0.0;
    } else if (encoded > 1.0) {
        encoded = 1.0;
    }

    return sixel_colorspace_clamp((int)(encoded * SIXEL_OKLAB_AB_SCALE + 0.5));
}

static inline double
sixel_oklab_decode_ab(unsigned char v)
{
    return (double)v / SIXEL_OKLAB_AB_SCALE - SIXEL_OKLAB_AB_OFFSET;
}

static inline unsigned char
sixel_cielab_encode_L(double L)
{
    double clamped;

    clamped = sixel_clamp_unit(L);
    return sixel_colorspace_clamp((int)(clamped * 255.0 + 0.5));
}

static inline unsigned char
sixel_cielab_encode_ab(double value)
{
    double shifted;
    double normalized;

    shifted = sixel_cielab_clamp_ab(value);
    normalized = (shifted / (2.0 * SIXEL_CIELAB_AB_LIMIT)) + 0.5;
    return sixel_colorspace_clamp((int)(normalized * 255.0 + 0.5));
}

static inline double
sixel_cielab_decode_ab(unsigned char v)
{
    double encoded;

    encoded = (double)v / 255.0;
    return (encoded - 0.5) * (2.0 * SIXEL_CIELAB_AB_LIMIT);
}

static inline unsigned char
sixel_din99d_encode_L(double L)
{
    double clamped;

    clamped = sixel_clamp_unit(L);
    return sixel_colorspace_clamp((int)(clamped * 255.0 + 0.5));
}

static inline unsigned char
sixel_din99d_encode_ab(double value)
{
    double normalized;

    normalized = (sixel_din99d_clamp_ab_norm(value) / 2.0) + 0.5;
    return sixel_colorspace_clamp((int)(normalized * 255.0 + 0.5));
}

static inline double
sixel_din99d_decode_ab(unsigned char v)
{
    double encoded;

    encoded = (double)v / 255.0;
    return sixel_din99d_clamp_ab_norm((encoded - 0.5) * 2.0);
}

static void
sixel_linear_to_cielab(double r, double g, double b,
                       double *L, double *A, double *B)
{
    const double Xn = 0.95047;
    const double Yn = 1.00000;
    const double Zn = 1.08883;
    double X;
    double Y;
    double Z;
    double fx;
    double fy;
    double fz;
    double L_component;
    double a_component;
    double b_component;

    X = 0.4124564 * r + 0.3575761 * g + 0.1804375 * b;
    Y = 0.2126729 * r + 0.7151522 * g + 0.0721750 * b;
    Z = 0.0193339 * r + 0.1191920 * g + 0.9503041 * b;

    fx = sixel_cielab_f(X / Xn);
    fy = sixel_cielab_f(Y / Yn);
    fz = sixel_cielab_f(Z / Zn);

    L_component = 116.0 * fy - 16.0;
    a_component = 500.0 * (fx - fy);
    b_component = 200.0 * (fy - fz);

    *L = sixel_clamp_unit(L_component / SIXEL_CIELAB_L_SCALE);
    *A = sixel_cielab_clamp_ab(a_component / SIXEL_CIELAB_AB_SCALE);
    *B = sixel_cielab_clamp_ab(b_component / SIXEL_CIELAB_AB_SCALE);
}

static void
sixel_cielab_to_linear(double L, double A, double B,
                       double *r, double *g, double *b)
{
    const double Xn = 0.95047;
    const double Yn = 1.00000;
    const double Zn = 1.08883;
    double L_component;
    double a_component;
    double b_component;
    double fx;
    double fy;
    double fz;
    double X;
    double Y;
    double Z;

    L_component = sixel_clamp_unit(L) * SIXEL_CIELAB_L_SCALE;
    a_component = sixel_cielab_clamp_ab(A) * SIXEL_CIELAB_AB_SCALE;
    b_component = sixel_cielab_clamp_ab(B) * SIXEL_CIELAB_AB_SCALE;

    fy = (L_component + 16.0) / 116.0;
    fx = fy + (a_component / 500.0);
    fz = fy - (b_component / 200.0);

    X = Xn * sixel_cielab_f_inv(fx);
    Y = Yn * sixel_cielab_f_inv(fy);
    Z = Zn * sixel_cielab_f_inv(fz);

    *r = 3.2404542 * X - 1.5371385 * Y - 0.4985314 * Z;
    *g = -0.9692660 * X + 1.8760108 * Y + 0.0415560 * Z;
    *b = 0.0556434 * X - 0.2040259 * Y + 1.0572252 * Z;

    *r = sixel_clamp_unit(*r);
    *g = sixel_clamp_unit(*g);
    *b = sixel_clamp_unit(*b);
}

static void
sixel_cielab_to_din99d(double L,
                       double a,
                       double b,
                       double *L99d,
                       double *A99d,
                       double *B99d)
{
    /* Convert from CIELAB to DIN99d using Cui et al. (2002) parameters. */
    const double c1 = 325.22;
    const double c2 = 0.0036;
    const double c3 = 50.0;
    const double c4 = 1.14;
    const double c5 = 22.5;
    const double c6 = 0.06;
    const double c7 = 50.0;
    const double c8 = 1.0;
    const double rad_per_degree = 3.14159265358979323846 / 180.0;
    double radians_c3;
    double radians_c7;
    double e;
    double f;
    double G;
    double h_ef;
    double C99;

    radians_c3 = c3 * rad_per_degree;
    radians_c7 = c7 * rad_per_degree;

    e = cos(radians_c3) * a + sin(radians_c3) * b;
    f = c4 * (-sin(radians_c3) * a + cos(radians_c3) * b);
    G = sqrt(e * e + f * f);
    h_ef = atan2(f, e) + radians_c7;

    C99 = c5 * (log1p(c6 * G)) / (c8);

    *A99d = C99 * cos(h_ef);
    *B99d = C99 * sin(h_ef);
    *L99d = c1 * log1p(c2 * L);
}

static void
sixel_din99d_to_cielab(double L99d,
                       double A99d,
                       double B99d,
                       double *L,
                       double *a,
                       double *b)
{
    /* Convert from DIN99d back to absolute CIELAB coordinates. */
    const double c1 = 325.22;
    const double c2 = 0.0036;
    const double c3 = 50.0;
    const double c4 = 1.14;
    const double c5 = 22.5;
    const double c6 = 0.06;
    const double c7 = 50.0;
    const double c8 = 1.0;
    const double rad_per_degree = 3.14159265358979323846 / 180.0;
    double radians_c3;
    double radians_c7;
    double h99;
    double C99;
    double G;
    double e;
    double f;

    radians_c3 = c3 * rad_per_degree;
    radians_c7 = c7 * rad_per_degree;

    h99 = atan2(B99d, A99d) - radians_c7;
    C99 = hypot(A99d, B99d);
    G = expm1((c8 / c5) * C99) / c6;

    e = G * cos(h99);
    f = G * sin(h99);

    *a = e * cos(radians_c3) - (f / c4) * sin(radians_c3);
    *b = e * sin(radians_c3) + (f / c4) * cos(radians_c3);
    *L = expm1(L99d / c1) / c2;
}

static void
sixel_linear_to_din99d(double r,
                       double g,
                       double b,
                       double *L99d_norm,
                       double *A99d_norm,
                       double *B99d_norm)
{
    double L;
    double A;
    double B;
    double L_star;
    double a_star;
    double b_star;
    double L99d;
    double A99d;
    double B99d;

    sixel_linear_to_cielab(r, g, b, &L, &A, &B);

    L_star = L * SIXEL_CIELAB_L_SCALE;
    a_star = A * SIXEL_CIELAB_AB_SCALE;
    b_star = B * SIXEL_CIELAB_AB_SCALE;

    sixel_cielab_to_din99d(L_star, a_star, b_star, &L99d, &A99d, &B99d);

    *L99d_norm = sixel_clamp_unit(L99d / SIXEL_DIN99D_L_SCALE);
    *A99d_norm = sixel_din99d_clamp_ab_norm(
        A99d / SIXEL_DIN99D_AB_RANGE);
    *B99d_norm = sixel_din99d_clamp_ab_norm(
        B99d / SIXEL_DIN99D_AB_RANGE);
}

static void
sixel_din99d_to_linear(double L99d_norm,
                       double A99d_norm,
                       double B99d_norm,
                       double *r,
                       double *g,
                       double *b)
{
    double L_star;
    double a_star;
    double b_star;
    double L;
    double A;
    double B;

    L = sixel_clamp_unit(L99d_norm) * SIXEL_DIN99D_L_SCALE;
    A = sixel_din99d_clamp_ab_norm(A99d_norm) * SIXEL_DIN99D_AB_RANGE;
    B = sixel_din99d_clamp_ab_norm(B99d_norm) * SIXEL_DIN99D_AB_RANGE;

    sixel_din99d_to_cielab(L, A, B, &L_star, &a_star, &b_star);

    L_star = sixel_clamp_unit(L_star / SIXEL_CIELAB_L_SCALE);
    a_star = sixel_cielab_clamp_ab(a_star / SIXEL_CIELAB_AB_SCALE);
    b_star = sixel_cielab_clamp_ab(b_star / SIXEL_CIELAB_AB_SCALE);

    sixel_cielab_to_linear(L_star, a_star, b_star, r, g, b);
}

static void
sixel_linear_to_oklab(double r, double g, double b,
                      double *L, double *A, double *B)
{
    double l;
    double m;
    double s;
    double l_;
    double m_;
    double s_;

    l = 0.4122214708 * r + 0.5363325363 * g + 0.0514459929 * b;
    m = 0.2119034982 * r + 0.6806995451 * g + 0.1073969566 * b;
    s = 0.0883024619 * r + 0.2817188376 * g + 0.6299787005 * b;

    l_ = cbrt(l);
    m_ = cbrt(m);
    s_ = cbrt(s);

    *L = 0.2104542553 * l_ + 0.7936177850 * m_ - 0.0040720468 * s_;
    *A = 1.9779984951 * l_ - 2.4285922050 * m_ + 0.4505937099 * s_;
    *B = 0.0259040371 * l_ + 0.7827717662 * m_ - 0.8086757660 * s_;
}

static void
sixel_oklab_to_linear(double L, double A, double B,
                      double *r, double *g, double *b)
{
    double l_;
    double m_;
    double s_;
    double l;
    double m;
    double s;

    l_ = L + 0.3963377774 * A + 0.2158037573 * B;
    m_ = L - 0.1055613458 * A - 0.0638541728 * B;
    s_ = L - 0.0894841775 * A - 1.2914855480 * B;

    l = l_ * l_ * l_;
    m = m_ * m_ * m_;
    s = s_ * s_ * s_;

    *r = 4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s;
    *g = -1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s;
    *b = -0.0041960863 * l - 0.7034186147 * m + 1.7076147010 * s;

    if (*r < 0.0) {
        *r = 0.0;
    }
    if (*g < 0.0) {
        *g = 0.0;
    }
    if (*b < 0.0) {
        *b = 0.0;
    }
}

static void
sixel_linear_srgb_to_smptec(double r, double g, double b,
                            double *rs, double *gs, double *bs)
{
    double sr;
    double sg;
    double sb;

    sr = sixel_linear_srgb_to_smptec_matrix[0][0] * r
       + sixel_linear_srgb_to_smptec_matrix[0][1] * g
       + sixel_linear_srgb_to_smptec_matrix[0][2] * b;
    sg = sixel_linear_srgb_to_smptec_matrix[1][0] * r
       + sixel_linear_srgb_to_smptec_matrix[1][1] * g
       + sixel_linear_srgb_to_smptec_matrix[1][2] * b;
    sb = sixel_linear_srgb_to_smptec_matrix[2][0] * r
       + sixel_linear_srgb_to_smptec_matrix[2][1] * g
       + sixel_linear_srgb_to_smptec_matrix[2][2] * b;

    *rs = sixel_clamp_unit(sr);
    *gs = sixel_clamp_unit(sg);
    *bs = sixel_clamp_unit(sb);
}

static void
sixel_linear_smptec_to_srgb(double rs, double gs, double bs,
                            double *r, double *g, double *b)
{
    double r_lin;
    double g_lin;
    double b_lin;

    r_lin = sixel_linear_smptec_to_srgb_matrix[0][0] * rs
          + sixel_linear_smptec_to_srgb_matrix[0][1] * gs
          + sixel_linear_smptec_to_srgb_matrix[0][2] * bs;
    g_lin = sixel_linear_smptec_to_srgb_matrix[1][0] * rs
          + sixel_linear_smptec_to_srgb_matrix[1][1] * gs
          + sixel_linear_smptec_to_srgb_matrix[1][2] * bs;
    b_lin = sixel_linear_smptec_to_srgb_matrix[2][0] * rs
          + sixel_linear_smptec_to_srgb_matrix[2][1] * gs
          + sixel_linear_smptec_to_srgb_matrix[2][2] * bs;

    *r = sixel_clamp_unit(r_lin);
    *g = sixel_clamp_unit(g_lin);
    *b = sixel_clamp_unit(b_lin);
}

static void
sixel_colorspace_init_tables(void)
{
    int i;
    double gamma_value;
    double linear_value;
    double converted;

    if (tables_initialized) {
        return;
    }

    for (i = 0; i < SIXEL_COLORSPACE_LUT_SIZE; ++i) {
        gamma_value = (double)i / 255.0;
        if (gamma_value <= 0.04045) {
            converted = gamma_value / 12.92;
        } else {
            converted = pow((gamma_value + 0.055) / 1.055, 2.4);
        }
        gamma_to_linear_lut[i] =
            sixel_colorspace_clamp((int)(converted * 255.0 + 0.5));
    }

    for (i = 0; i < SIXEL_COLORSPACE_LUT_SIZE; ++i) {
        linear_value = (double)i / 255.0;
        if (linear_value <= 0.0031308) {
            converted = linear_value * 12.92;
        } else {
            converted = 1.055 * pow(linear_value, 1.0 / 2.4) - 0.055;
        }
        linear_to_gamma_lut[i] =
            sixel_colorspace_clamp((int)(converted * 255.0 + 0.5));
    }

    tables_initialized = 1;
}

static void
sixel_decode_linear_from_colorspace(int colorspace,
                                    unsigned char r8,
                                    unsigned char g8,
                                    unsigned char b8,
                                    double *r_lin,
                                    double *g_lin,
                                    double *b_lin)
{
    switch (colorspace) {
    case SIXEL_COLORSPACE_GAMMA:
        *r_lin = sixel_srgb_to_linear_double(r8);
        *g_lin = sixel_srgb_to_linear_double(g8);
        *b_lin = sixel_srgb_to_linear_double(b8);
        break;
    case SIXEL_COLORSPACE_LINEAR:
        *r_lin = (double)r8 / 255.0;
        *g_lin = (double)g8 / 255.0;
        *b_lin = (double)b8 / 255.0;
        break;
    case SIXEL_COLORSPACE_OKLAB:
    {
        double L = (double)r8 / 255.0;
        double A = sixel_oklab_decode_ab(g8);
        double B = sixel_oklab_decode_ab(b8);
        sixel_oklab_to_linear(L, A, B, r_lin, g_lin, b_lin);
        break;
    }
    case SIXEL_COLORSPACE_CIELAB:
    {
        double L;
        double A;
        double B;

        L = (double)r8 / 255.0;
        A = sixel_cielab_decode_ab(g8);
        B = sixel_cielab_decode_ab(b8);
        sixel_cielab_to_linear(L, A, B, r_lin, g_lin, b_lin);
        break;
    }
    case SIXEL_COLORSPACE_DIN99D:
    {
        double L;
        double A;
        double B;

        L = (double)r8 / 255.0;
        A = sixel_din99d_decode_ab(g8);
        B = sixel_din99d_decode_ab(b8);
        sixel_din99d_to_linear(L, A, B, r_lin, g_lin, b_lin);
        break;
    }
    case SIXEL_COLORSPACE_SMPTEC:
    {
        double r_smptec = sixel_smptec_to_linear_double(r8);
        double g_smptec = sixel_smptec_to_linear_double(g8);
        double b_smptec = sixel_smptec_to_linear_double(b8);
        sixel_linear_smptec_to_srgb(r_smptec, g_smptec, b_smptec,
                                    r_lin, g_lin, b_lin);
        break;
    }
    default:
        *r_lin = (double)r8 / 255.0;
        *g_lin = (double)g8 / 255.0;
        *b_lin = (double)b8 / 255.0;
        break;
    }
}

/*
 * Float variant of the colorspace decoder so RGBFLOAT32 buffers can skip the
 * byte quantisation that the legacy helper performs.
 */
static void
sixel_decode_linear_from_colorspace_float(int colorspace,
                                          float r_value,
                                          float g_value,
                                          float b_value,
                                          double *r_lin,
                                          double *g_lin,
                                          double *b_lin)
{
    double r;
    double g;
    double b;

    r = (double)r_value;
    g = (double)g_value;
    b = (double)b_value;

    switch (colorspace) {
    case SIXEL_COLORSPACE_GAMMA:
        *r_lin = sixel_srgb_unit_to_linear(r);
        *g_lin = sixel_srgb_unit_to_linear(g);
        *b_lin = sixel_srgb_unit_to_linear(b);
        break;
    case SIXEL_COLORSPACE_LINEAR:
        *r_lin = sixel_clamp_unit(r);
        *g_lin = sixel_clamp_unit(g);
        *b_lin = sixel_clamp_unit(b);
        break;
    case SIXEL_COLORSPACE_OKLAB:
        sixel_oklab_to_linear(r, g, b, r_lin, g_lin, b_lin);
        break;
    case SIXEL_COLORSPACE_CIELAB:
        sixel_cielab_to_linear(r, g, b, r_lin, g_lin, b_lin);
        break;
    case SIXEL_COLORSPACE_DIN99D:
        sixel_din99d_to_linear(r, g, b, r_lin, g_lin, b_lin);
        break;
    case SIXEL_COLORSPACE_SMPTEC:
    {
        double r_smptec;
        double g_smptec;
        double b_smptec;

        r_smptec = sixel_smptec_unit_to_linear(r);
        g_smptec = sixel_smptec_unit_to_linear(g);
        b_smptec = sixel_smptec_unit_to_linear(b);
        sixel_linear_smptec_to_srgb(r_smptec,
                                    g_smptec,
                                    b_smptec,
                                    r_lin,
                                    g_lin,
                                    b_lin);
        break;
    }
    default:
        *r_lin = sixel_clamp_unit(r);
        *g_lin = sixel_clamp_unit(g);
        *b_lin = sixel_clamp_unit(b);
        break;
    }
}

static void
sixel_encode_linear_to_colorspace(int colorspace,
                                  double r_lin,
                                  double g_lin,
                                  double b_lin,
                                  unsigned char *r8,
                                  unsigned char *g8,
                                  unsigned char *b8)
{
    double L;
    double A;
    double B;

    switch (colorspace) {
    case SIXEL_COLORSPACE_GAMMA:
        *r8 = sixel_linear_double_to_srgb(r_lin);
        *g8 = sixel_linear_double_to_srgb(g_lin);
        *b8 = sixel_linear_double_to_srgb(b_lin);
        break;
    case SIXEL_COLORSPACE_LINEAR:
        *r8 = sixel_linear_double_to_byte(r_lin);
        *g8 = sixel_linear_double_to_byte(g_lin);
        *b8 = sixel_linear_double_to_byte(b_lin);
        break;
    case SIXEL_COLORSPACE_OKLAB:
        sixel_linear_to_oklab(r_lin, g_lin, b_lin, &L, &A, &B);
        *r8 = sixel_oklab_encode_L(L);
        *g8 = sixel_oklab_encode_ab(A);
        *b8 = sixel_oklab_encode_ab(B);
        break;
    case SIXEL_COLORSPACE_CIELAB:
        sixel_linear_to_cielab(r_lin, g_lin, b_lin, &L, &A, &B);
        *r8 = sixel_cielab_encode_L(L);
        *g8 = sixel_cielab_encode_ab(A);
        *b8 = sixel_cielab_encode_ab(B);
        break;
    case SIXEL_COLORSPACE_DIN99D:
        sixel_linear_to_din99d(r_lin, g_lin, b_lin, &L, &A, &B);
        *r8 = sixel_din99d_encode_L(L);
        *g8 = sixel_din99d_encode_ab(A);
        *b8 = sixel_din99d_encode_ab(B);
        break;
    case SIXEL_COLORSPACE_SMPTEC:
    {
        double r_smptec;
        double g_smptec;
        double b_smptec;

        sixel_linear_srgb_to_smptec(r_lin, g_lin, b_lin,
                                     &r_smptec, &g_smptec, &b_smptec);

        *r8 = sixel_linear_double_to_smptec(r_smptec);
        *g8 = sixel_linear_double_to_smptec(g_smptec);
        *b8 = sixel_linear_double_to_smptec(b_smptec);
        break;
    }
    default:
        *r8 = sixel_linear_double_to_byte(r_lin);
        *g8 = sixel_linear_double_to_byte(g_lin);
        *b8 = sixel_linear_double_to_byte(b_lin);
        break;
    }
}

static void
sixel_encode_linear_to_colorspace_float(int colorspace,
                                        double r_lin,
                                        double g_lin,
                                        double b_lin,
                                        float *r_value,
                                        float *g_value,
                                        float *b_value)
{
    double r;
    double g;
    double b;

    switch (colorspace) {
    case SIXEL_COLORSPACE_GAMMA:
        r = sixel_linear_to_srgb_unit(r_lin);
        g = sixel_linear_to_srgb_unit(g_lin);
        b = sixel_linear_to_srgb_unit(b_lin);
        break;
    case SIXEL_COLORSPACE_LINEAR:
        r = sixel_clamp_unit(r_lin);
        g = sixel_clamp_unit(g_lin);
        b = sixel_clamp_unit(b_lin);
        break;
    case SIXEL_COLORSPACE_OKLAB:
        sixel_linear_to_oklab(r_lin, g_lin, b_lin, &r, &g, &b);
        r = sixel_clamp_unit(r);
        g = sixel_oklab_clamp_ab(g);
        b = sixel_oklab_clamp_ab(b);
        break;
    case SIXEL_COLORSPACE_CIELAB:
        sixel_linear_to_cielab(r_lin, g_lin, b_lin, &r, &g, &b);
        r = sixel_clamp_unit(r);
        g = sixel_cielab_clamp_ab(g);
        b = sixel_cielab_clamp_ab(b);
        break;
    case SIXEL_COLORSPACE_DIN99D:
        sixel_linear_to_din99d(r_lin, g_lin, b_lin, &r, &g, &b);
        r = sixel_clamp_unit(r);
        g = sixel_din99d_clamp_ab_norm(g);
        b = sixel_din99d_clamp_ab_norm(b);
        break;
    case SIXEL_COLORSPACE_SMPTEC:
    {
        double r_smptec;
        double g_smptec;
        double b_smptec;

        sixel_linear_srgb_to_smptec(r_lin,
                                     g_lin,
                                     b_lin,
                                     &r_smptec,
                                     &g_smptec,
                                     &b_smptec);
        r = sixel_linear_to_smptec_unit(r_smptec);
        g = sixel_linear_to_smptec_unit(g_smptec);
        b = sixel_linear_to_smptec_unit(b_smptec);
        break;
    }
    default:
        r = sixel_clamp_unit(r_lin);
        g = sixel_clamp_unit(g_lin);
        b = sixel_clamp_unit(b_lin);
        break;
    }

    *r_value = (float)r;
    *g_value = (float)g;
    *b_value = (float)b;
}

static SIXELSTATUS
sixel_convert_pixels_via_linear(unsigned char *pixels,
                                size_t size,
                                int pixelformat,
                                int colorspace_src,
                                int colorspace_dst)
{
    size_t i;
    int step;
    int index_r;
    int index_g;
    int index_b;

    if (colorspace_src == colorspace_dst) {
        return SIXEL_OK;
    }

    switch (pixelformat) {
    case SIXEL_PIXELFORMAT_RGB888:
        step = 3;
        index_r = 0;
        index_g = 1;
        index_b = 2;
        break;
    case SIXEL_PIXELFORMAT_BGR888:
        step = 3;
        index_r = 2;
        index_g = 1;
        index_b = 0;
        break;
    case SIXEL_PIXELFORMAT_RGBA8888:
        step = 4;
        index_r = 0;
        index_g = 1;
        index_b = 2;
        break;
    case SIXEL_PIXELFORMAT_BGRA8888:
        step = 4;
        index_r = 2;
        index_g = 1;
        index_b = 0;
        break;
    case SIXEL_PIXELFORMAT_ARGB8888:
        step = 4;
        index_r = 1;
        index_g = 2;
        index_b = 3;
        break;
    case SIXEL_PIXELFORMAT_ABGR8888:
        step = 4;
        index_r = 3;
        index_g = 2;
        index_b = 1;
        break;
    case SIXEL_PIXELFORMAT_G8:
        step = 1;
        index_r = 0;
        index_g = 0;
        index_b = 0;
        break;
    case SIXEL_PIXELFORMAT_GA88:
        step = 2;
        index_r = 0;
        index_g = 0;
        index_b = 0;
        break;
    case SIXEL_PIXELFORMAT_AG88:
        step = 2;
        index_r = 1;
        index_g = 1;
        index_b = 1;
        break;
    default:
        return SIXEL_BAD_INPUT;
    }

    if (size % (size_t)step != 0) {
        return SIXEL_BAD_INPUT;
    }

    for (i = 0; i < size; i += (size_t)step) {
        unsigned char *pr = pixels + i + (size_t)index_r;
        unsigned char *pg = pixels + i + (size_t)index_g;
        unsigned char *pb = pixels + i + (size_t)index_b;
        double r_lin;
        double g_lin;
        double b_lin;

        sixel_decode_linear_from_colorspace(colorspace_src,
                                            *pr,
                                            *pg,
                                            *pb,
                                            &r_lin,
                                            &g_lin,
                                            &b_lin);

        sixel_encode_linear_to_colorspace(colorspace_dst,
                                          r_lin,
                                          g_lin,
                                          b_lin,
                                          pr,
                                          pg,
                                          pb);
    }

    return SIXEL_OK;
}

/*
 * Convert RGBFLOAT32 buffers in-place by round-tripping through linear space
 * with double intermediates.  This keeps OKLab/linear conversions precise
 * while sharing the same matrices as the byte implementation.
 */
static SIXELSTATUS
sixel_convert_pixels_via_linear_float(float *pixels,
                                      size_t size,
                                      int colorspace_src,
                                      int colorspace_dst)
{
    size_t pixel_total;
    size_t index;
    size_t base;
    double r_lin;
    double g_lin;
    double b_lin;
    float *pr;
    float *pg;
    float *pb;

    if (colorspace_src == colorspace_dst) {
        return SIXEL_OK;
    }

    if (size % (3U * sizeof(float)) != 0U) {
        return SIXEL_BAD_INPUT;
    }

    pixel_total = size / (3U * sizeof(float));
    for (index = 0U; index < pixel_total; ++index) {
        base = index * 3U;
        pr = pixels + base + 0U;
        pg = pixels + base + 1U;
        pb = pixels + base + 2U;

        sixel_decode_linear_from_colorspace_float(colorspace_src,
                                                  *pr,
                                                  *pg,
                                                  *pb,
                                                  &r_lin,
                                                  &g_lin,
                                                  &b_lin);

        sixel_encode_linear_to_colorspace_float(colorspace_dst,
                                                r_lin,
                                                g_lin,
                                                b_lin,
                                                pr,
                                                pg,
                                                pb);
    }

    return SIXEL_OK;
}

static unsigned char
sixel_colorspace_convert_component(unsigned char value,
                                   int colorspace_src,
                                   int colorspace_dst)
{
    if (colorspace_src == colorspace_dst) {
        return value;
    }

    if (colorspace_src == SIXEL_COLORSPACE_GAMMA &&
            colorspace_dst == SIXEL_COLORSPACE_LINEAR) {
        return gamma_to_linear_lut[value];
    }

    if (colorspace_src == SIXEL_COLORSPACE_LINEAR &&
            colorspace_dst == SIXEL_COLORSPACE_GAMMA) {
        return linear_to_gamma_lut[value];
    }

    return value;
}

int
sixel_colorspace_supports_pixelformat(int pixelformat)
{
    switch (pixelformat) {
    case SIXEL_PIXELFORMAT_RGB888:
    case SIXEL_PIXELFORMAT_BGR888:
    case SIXEL_PIXELFORMAT_RGBA8888:
    case SIXEL_PIXELFORMAT_ARGB8888:
    case SIXEL_PIXELFORMAT_BGRA8888:
    case SIXEL_PIXELFORMAT_ABGR8888:
    case SIXEL_PIXELFORMAT_G8:
    case SIXEL_PIXELFORMAT_GA88:
    case SIXEL_PIXELFORMAT_AG88:
    case SIXEL_PIXELFORMAT_RGBFLOAT32:
    case SIXEL_PIXELFORMAT_LINEARRGBFLOAT32:
    case SIXEL_PIXELFORMAT_OKLABFLOAT32:
    case SIXEL_PIXELFORMAT_CIELABFLOAT32:
    case SIXEL_PIXELFORMAT_DIN99DFLOAT32:
        return 1;
    default:
        break;
    }

    return 0;
}

SIXELAPI SIXELSTATUS
sixel_helper_convert_colorspace(unsigned char *pixels,
                                size_t size,
                                int pixelformat,
                                int colorspace_src,
                                int colorspace_dst)
{
    size_t i;

    if (pixels == NULL) {
        sixel_helper_set_additional_message(
            "sixel_helper_convert_colorspace: pixels is null.");
        return SIXEL_BAD_ARGUMENT;
    }

    if (colorspace_src == colorspace_dst) {
        return SIXEL_OK;
    }

    if (!sixel_colorspace_supports_pixelformat(pixelformat)) {
        sixel_helper_set_additional_message(
            "sixel_helper_convert_colorspace: unsupported pixelformat.");
        return SIXEL_BAD_INPUT;
    }

    sixel_colorspace_init_tables();

    if (SIXEL_PIXELFORMAT_IS_FLOAT32(pixelformat)) {
        return sixel_convert_pixels_via_linear_float((float *)pixels,
                                                     size,
                                                     colorspace_src,
                                                     colorspace_dst);
    }

    if (colorspace_src == SIXEL_COLORSPACE_OKLAB ||
            colorspace_dst == SIXEL_COLORSPACE_OKLAB ||
            colorspace_src == SIXEL_COLORSPACE_CIELAB ||
            colorspace_dst == SIXEL_COLORSPACE_CIELAB ||
            colorspace_src == SIXEL_COLORSPACE_DIN99D ||
            colorspace_dst == SIXEL_COLORSPACE_DIN99D ||
            colorspace_src == SIXEL_COLORSPACE_SMPTEC ||
            colorspace_dst == SIXEL_COLORSPACE_SMPTEC) {
        SIXELSTATUS status = sixel_convert_pixels_via_linear(pixels,
                                                             size,
                                                             pixelformat,
                                                             colorspace_src,
                                                             colorspace_dst);
        if (SIXEL_FAILED(status)) {
            sixel_helper_set_additional_message(
                "sixel_helper_convert_colorspace: unsupported pixelformat for conversion.");
        }
        return status;
    }

    switch (pixelformat) {
    case SIXEL_PIXELFORMAT_RGB888:
        if (size % 3 != 0) {
            sixel_helper_set_additional_message(
                "sixel_helper_convert_colorspace: invalid data size.");
            return SIXEL_BAD_INPUT;
        }
        for (i = 0; i + 2 < size; i += 3) {
            pixels[i + 0] = sixel_colorspace_convert_component(
                pixels[i + 0], colorspace_src, colorspace_dst);
            pixels[i + 1] = sixel_colorspace_convert_component(
                pixels[i + 1], colorspace_src, colorspace_dst);
            pixels[i + 2] = sixel_colorspace_convert_component(
                pixels[i + 2], colorspace_src, colorspace_dst);
        }
        break;
    case SIXEL_PIXELFORMAT_BGR888:
        if (size % 3 != 0) {
            sixel_helper_set_additional_message(
                "sixel_helper_convert_colorspace: invalid data size.");
            return SIXEL_BAD_INPUT;
        }
        for (i = 0; i + 2 < size; i += 3) {
            pixels[i + 0] = sixel_colorspace_convert_component(
                pixels[i + 0], colorspace_src, colorspace_dst);
            pixels[i + 1] = sixel_colorspace_convert_component(
                pixels[i + 1], colorspace_src, colorspace_dst);
            pixels[i + 2] = sixel_colorspace_convert_component(
                pixels[i + 2], colorspace_src, colorspace_dst);
        }
        break;
    case SIXEL_PIXELFORMAT_RGBA8888:
        if (size % 4 != 0) {
            sixel_helper_set_additional_message(
                "sixel_helper_convert_colorspace: invalid data size.");
            return SIXEL_BAD_INPUT;
        }
        for (i = 0; i + 3 < size; i += 4) {
            pixels[i + 0] = sixel_colorspace_convert_component(
                pixels[i + 0], colorspace_src, colorspace_dst);
            pixels[i + 1] = sixel_colorspace_convert_component(
                pixels[i + 1], colorspace_src, colorspace_dst);
            pixels[i + 2] = sixel_colorspace_convert_component(
                pixels[i + 2], colorspace_src, colorspace_dst);
        }
        break;
    case SIXEL_PIXELFORMAT_ARGB8888:
        if (size % 4 != 0) {
            sixel_helper_set_additional_message(
                "sixel_helper_convert_colorspace: invalid data size.");
            return SIXEL_BAD_INPUT;
        }
        for (i = 0; i + 3 < size; i += 4) {
            pixels[i + 1] = sixel_colorspace_convert_component(
                pixels[i + 1], colorspace_src, colorspace_dst);
            pixels[i + 2] = sixel_colorspace_convert_component(
                pixels[i + 2], colorspace_src, colorspace_dst);
            pixels[i + 3] = sixel_colorspace_convert_component(
                pixels[i + 3], colorspace_src, colorspace_dst);
        }
        break;
    case SIXEL_PIXELFORMAT_BGRA8888:
        if (size % 4 != 0) {
            sixel_helper_set_additional_message(
                "sixel_helper_convert_colorspace: invalid data size.");
            return SIXEL_BAD_INPUT;
        }
        for (i = 0; i + 3 < size; i += 4) {
            pixels[i + 0] = sixel_colorspace_convert_component(
                pixels[i + 0], colorspace_src, colorspace_dst);
            pixels[i + 1] = sixel_colorspace_convert_component(
                pixels[i + 1], colorspace_src, colorspace_dst);
            pixels[i + 2] = sixel_colorspace_convert_component(
                pixels[i + 2], colorspace_src, colorspace_dst);
        }
        break;
    case SIXEL_PIXELFORMAT_ABGR8888:
        if (size % 4 != 0) {
            sixel_helper_set_additional_message(
                "sixel_helper_convert_colorspace: invalid data size.");
            return SIXEL_BAD_INPUT;
        }
        for (i = 0; i + 3 < size; i += 4) {
            pixels[i + 1] = sixel_colorspace_convert_component(
                pixels[i + 1], colorspace_src, colorspace_dst);
            pixels[i + 2] = sixel_colorspace_convert_component(
                pixels[i + 2], colorspace_src, colorspace_dst);
            pixels[i + 3] = sixel_colorspace_convert_component(
                pixels[i + 3], colorspace_src, colorspace_dst);
        }
        break;
    case SIXEL_PIXELFORMAT_G8:
        for (i = 0; i < size; ++i) {
            pixels[i] = sixel_colorspace_convert_component(
                pixels[i], colorspace_src, colorspace_dst);
        }
        break;
    case SIXEL_PIXELFORMAT_GA88:
        if (size % 2 != 0) {
            sixel_helper_set_additional_message(
                "sixel_helper_convert_colorspace: invalid data size.");
            return SIXEL_BAD_INPUT;
        }
        for (i = 0; i + 1 < size; i += 2) {
            pixels[i + 0] = sixel_colorspace_convert_component(
                pixels[i + 0], colorspace_src, colorspace_dst);
        }
        break;
    case SIXEL_PIXELFORMAT_AG88:
        if (size % 2 != 0) {
            sixel_helper_set_additional_message(
                "sixel_helper_convert_colorspace: invalid data size.");
            return SIXEL_BAD_INPUT;
        }
        for (i = 0; i + 1 < size; i += 2) {
            pixels[i + 1] = sixel_colorspace_convert_component(
                pixels[i + 1], colorspace_src, colorspace_dst);
        }
        break;
    default:
        sixel_helper_set_additional_message(
            "sixel_helper_convert_colorspace: unsupported pixelformat.");
        return SIXEL_BAD_INPUT;
    }

    return SIXEL_OK;
}

/* emacs Local Variables:      */
/* emacs mode: c               */
/* emacs tab-width: 4          */
/* emacs indent-tabs-mode: nil */
/* emacs c-basic-offset: 4     */
/* emacs End:                  */
/* vim: set expandtab ts=4 sts=4 sw=4 : */
/* EOF */

saitoha / libsixel / 19765269522

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous