You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
487 lines
12 KiB
487 lines
12 KiB
/*
|
|
* Copyright 2019 Sebastian Wick
|
|
* Copyright 2021 Collabora, Ltd.
|
|
*
|
|
* 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 (including the
|
|
* next paragraph) 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 <assert.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <libweston/libweston.h>
|
|
|
|
#include "color.h"
|
|
#include "color-lcms.h"
|
|
#include "shared/helpers.h"
|
|
#include "shared/string-helpers.h"
|
|
|
|
struct xyz_arr_flt {
|
|
float v[3];
|
|
};
|
|
|
|
static double
|
|
xyz_dot_prod(const struct xyz_arr_flt a, const struct xyz_arr_flt b)
|
|
{
|
|
return (double)a.v[0] * b.v[0] +
|
|
(double)a.v[1] * b.v[1] +
|
|
(double)a.v[2] * b.v[2];
|
|
}
|
|
|
|
/**
|
|
* Graeme sketched a linearization method there:
|
|
* https://lists.freedesktop.org/archives/wayland-devel/2019-March/040171.html
|
|
*/
|
|
static bool
|
|
build_eotf_from_clut_profile(cmsContext lcms_ctx,
|
|
cmsHPROFILE profile,
|
|
cmsToneCurve *output_eotf[3],
|
|
int num_points)
|
|
{
|
|
int ch, point;
|
|
float *curve_array[3];
|
|
float *red = NULL;
|
|
cmsHPROFILE xyz_profile = NULL;
|
|
cmsHTRANSFORM transform_rgb_to_xyz = NULL;
|
|
bool ret = false;
|
|
const float div = num_points - 1;
|
|
|
|
red = malloc(sizeof(float) * num_points * 3);
|
|
if (!red)
|
|
goto release;
|
|
|
|
curve_array[0] = red;
|
|
curve_array[1] = red + num_points;
|
|
curve_array[2] = red + 2 * num_points;
|
|
|
|
xyz_profile = cmsCreateXYZProfileTHR(lcms_ctx);
|
|
if (!xyz_profile)
|
|
goto release;
|
|
|
|
transform_rgb_to_xyz = cmsCreateTransformTHR(lcms_ctx, profile,
|
|
TYPE_RGB_FLT, xyz_profile,
|
|
TYPE_XYZ_FLT,
|
|
INTENT_ABSOLUTE_COLORIMETRIC,
|
|
0);
|
|
if (!transform_rgb_to_xyz)
|
|
goto release;
|
|
|
|
for (ch = 0; ch < 3; ch++) {
|
|
struct xyz_arr_flt prim_xyz_max;
|
|
struct xyz_arr_flt prim_xyz;
|
|
double xyz_square_magnitude;
|
|
float rgb[3] = { 0.0f, 0.0f, 0.0f };
|
|
|
|
rgb[ch] = 1.0f;
|
|
cmsDoTransform(transform_rgb_to_xyz, rgb, prim_xyz_max.v, 1);
|
|
|
|
/**
|
|
* Calculate xyz square of magnitude uses single channel 100% and
|
|
* others are zero.
|
|
*/
|
|
xyz_square_magnitude = xyz_dot_prod(prim_xyz_max, prim_xyz_max);
|
|
/**
|
|
* Build rgb tone curves
|
|
*/
|
|
for (point = 0; point < num_points; point++) {
|
|
rgb[ch] = (float)point / div;
|
|
cmsDoTransform(transform_rgb_to_xyz, rgb, prim_xyz.v, 1);
|
|
curve_array[ch][point] = xyz_dot_prod(prim_xyz,
|
|
prim_xyz_max) /
|
|
xyz_square_magnitude;
|
|
}
|
|
|
|
/**
|
|
* Create LCMS object of rgb tone curves and validate whether
|
|
* monotonic
|
|
*/
|
|
output_eotf[ch] = cmsBuildTabulatedToneCurveFloat(lcms_ctx,
|
|
num_points,
|
|
curve_array[ch]);
|
|
if (!output_eotf[ch])
|
|
goto release;
|
|
if (!cmsIsToneCurveMonotonic(output_eotf[ch])) {
|
|
/**
|
|
* It is interesting to see how this profile was created.
|
|
* We assume that such a curve could not be used for linearization
|
|
* of arbitrary profile.
|
|
*/
|
|
goto release;
|
|
}
|
|
}
|
|
ret = true;
|
|
|
|
release:
|
|
if (transform_rgb_to_xyz)
|
|
cmsDeleteTransform(transform_rgb_to_xyz);
|
|
if (xyz_profile)
|
|
cmsCloseProfile(xyz_profile);
|
|
free(red);
|
|
if (ret == false)
|
|
cmsFreeToneCurveTriple(output_eotf);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* Concatenation of two monotonic tone curves.
|
|
* LCMS API cmsJoinToneCurve does y = Y^-1(X(t)),
|
|
* but want to have y = Y^(X(t))
|
|
*/
|
|
static cmsToneCurve *
|
|
lcmsJoinToneCurve(cmsContext context_id, const cmsToneCurve *X,
|
|
const cmsToneCurve *Y, unsigned int resulting_points)
|
|
{
|
|
cmsToneCurve *out = NULL;
|
|
float t, x;
|
|
float *res = NULL;
|
|
unsigned int i;
|
|
|
|
res = zalloc(resulting_points * sizeof(float));
|
|
if (res == NULL)
|
|
goto error;
|
|
|
|
for (i = 0; i < resulting_points; i++) {
|
|
t = (float)i / (resulting_points - 1);
|
|
x = cmsEvalToneCurveFloat(X, t);
|
|
res[i] = cmsEvalToneCurveFloat(Y, x);
|
|
}
|
|
|
|
out = cmsBuildTabulatedToneCurveFloat(context_id, resulting_points, res);
|
|
|
|
error:
|
|
if (res != NULL)
|
|
free(res);
|
|
|
|
return out;
|
|
}
|
|
/**
|
|
* Extract EOTF from matrix-shaper and cLUT profiles,
|
|
* then invert and concatenate with 'vcgt' curve if it
|
|
* is available.
|
|
*/
|
|
bool
|
|
retrieve_eotf_and_output_inv_eotf(cmsContext lcms_ctx,
|
|
cmsHPROFILE hProfile,
|
|
cmsToneCurve *output_eotf[3],
|
|
cmsToneCurve *output_inv_eotf_vcgt[3],
|
|
cmsToneCurve *vcgt[3],
|
|
unsigned int num_points)
|
|
{
|
|
cmsToneCurve *curve = NULL;
|
|
const cmsToneCurve * const *vcgt_curves;
|
|
unsigned i;
|
|
cmsTagSignature tags[] = {
|
|
cmsSigRedTRCTag, cmsSigGreenTRCTag, cmsSigBlueTRCTag
|
|
};
|
|
|
|
if (cmsIsMatrixShaper(hProfile)) {
|
|
/**
|
|
* Optimization for matrix-shaper profile
|
|
* May have 1DLUT->3x3->3x3->1DLUT, 1DLUT->3x3->1DLUT
|
|
*/
|
|
for (i = 0 ; i < 3; i++) {
|
|
curve = cmsReadTag(hProfile, tags[i]);
|
|
if (!curve)
|
|
goto fail;
|
|
output_eotf[i] = cmsDupToneCurve(curve);
|
|
if (!output_eotf[i])
|
|
goto fail;
|
|
}
|
|
} else {
|
|
/**
|
|
* Linearization of cLUT profile may have 1DLUT->3DLUT->1DLUT,
|
|
* 1DLUT->3DLUT, 3DLUT
|
|
*/
|
|
if (!build_eotf_from_clut_profile(lcms_ctx, hProfile,
|
|
output_eotf, num_points))
|
|
goto fail;
|
|
}
|
|
/**
|
|
* If the caller looking for eotf only then return early.
|
|
* It could be used for input profile when identity case: EOTF + INV_EOTF
|
|
* in pipeline only.
|
|
*/
|
|
if (output_inv_eotf_vcgt == NULL)
|
|
return true;
|
|
|
|
for (i = 0; i < 3; i++) {
|
|
curve = cmsReverseToneCurve(output_eotf[i]);
|
|
if (!curve)
|
|
goto fail;
|
|
output_inv_eotf_vcgt[i] = curve;
|
|
}
|
|
vcgt_curves = cmsReadTag(hProfile, cmsSigVcgtTag);
|
|
if (vcgt_curves && vcgt_curves[0] && vcgt_curves[1] && vcgt_curves[2]) {
|
|
for (i = 0; i < 3; i++) {
|
|
curve = lcmsJoinToneCurve(lcms_ctx,
|
|
output_inv_eotf_vcgt[i],
|
|
vcgt_curves[i], num_points);
|
|
if (!curve)
|
|
goto fail;
|
|
cmsFreeToneCurve(output_inv_eotf_vcgt[i]);
|
|
output_inv_eotf_vcgt[i] = curve;
|
|
if (vcgt)
|
|
vcgt[i] = cmsDupToneCurve(vcgt_curves[i]);
|
|
}
|
|
}
|
|
return true;
|
|
|
|
fail:
|
|
cmsFreeToneCurveTriple(output_eotf);
|
|
cmsFreeToneCurveTriple(output_inv_eotf_vcgt);
|
|
return false;
|
|
}
|
|
|
|
/* FIXME: sync with spec! */
|
|
static bool
|
|
validate_icc_profile(cmsHPROFILE profile, char **errmsg)
|
|
{
|
|
cmsColorSpaceSignature cs = cmsGetColorSpace(profile);
|
|
uint32_t nr_channels = cmsChannelsOf(cs);
|
|
uint8_t version = cmsGetEncodedICCversion(profile) >> 24;
|
|
|
|
if (version != 2 && version != 4) {
|
|
str_printf(errmsg,
|
|
"ICC profile major version %d is unsupported, should be 2 or 4.",
|
|
version);
|
|
return false;
|
|
}
|
|
|
|
if (nr_channels != 3) {
|
|
str_printf(errmsg,
|
|
"ICC profile must contain 3 channels for the color space, not %u.",
|
|
nr_channels);
|
|
return false;
|
|
}
|
|
|
|
if (cmsGetDeviceClass(profile) != cmsSigDisplayClass) {
|
|
str_printf(errmsg, "ICC profile is required to be of Display device class, but it is not.");
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static struct cmlcms_color_profile *
|
|
cmlcms_find_color_profile_by_md5(const struct weston_color_manager_lcms *cm,
|
|
const struct cmlcms_md5_sum *md5sum)
|
|
{
|
|
struct cmlcms_color_profile *cprof;
|
|
|
|
wl_list_for_each(cprof, &cm->color_profile_list, link) {
|
|
if (memcmp(cprof->md5sum.bytes,
|
|
md5sum->bytes, sizeof(md5sum->bytes)) == 0)
|
|
return cprof;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static struct cmlcms_color_profile *
|
|
cmlcms_color_profile_create(struct weston_color_manager_lcms *cm,
|
|
cmsHPROFILE profile,
|
|
char *desc,
|
|
char **errmsg)
|
|
{
|
|
struct cmlcms_color_profile *cprof;
|
|
|
|
cprof = zalloc(sizeof *cprof);
|
|
if (!cprof)
|
|
return NULL;
|
|
|
|
weston_color_profile_init(&cprof->base, &cm->base);
|
|
cprof->base.description = desc;
|
|
cprof->profile = profile;
|
|
cmsGetHeaderProfileID(profile, cprof->md5sum.bytes);
|
|
wl_list_insert(&cm->color_profile_list, &cprof->link);
|
|
|
|
return cprof;
|
|
}
|
|
|
|
void
|
|
cmlcms_color_profile_destroy(struct cmlcms_color_profile *cprof)
|
|
{
|
|
wl_list_remove(&cprof->link);
|
|
cmsFreeToneCurveTriple(cprof->vcgt);
|
|
cmsFreeToneCurveTriple(cprof->output_eotf);
|
|
cmsFreeToneCurveTriple(cprof->output_inv_eotf_vcgt);
|
|
cmsCloseProfile(cprof->profile);
|
|
free(cprof->base.description);
|
|
free(cprof);
|
|
}
|
|
|
|
struct cmlcms_color_profile *
|
|
ref_cprof(struct cmlcms_color_profile *cprof)
|
|
{
|
|
if (!cprof)
|
|
return NULL;
|
|
|
|
weston_color_profile_ref(&cprof->base);
|
|
return cprof;
|
|
}
|
|
|
|
void
|
|
unref_cprof(struct cmlcms_color_profile *cprof)
|
|
{
|
|
if (!cprof)
|
|
return;
|
|
|
|
weston_color_profile_unref(&cprof->base);
|
|
}
|
|
|
|
static char *
|
|
make_icc_file_description(cmsHPROFILE profile,
|
|
const struct cmlcms_md5_sum *md5sum,
|
|
const char *name_part)
|
|
{
|
|
char md5sum_str[sizeof(md5sum->bytes) * 2 + 1];
|
|
char *desc;
|
|
size_t i;
|
|
|
|
for (i = 0; i < sizeof(md5sum->bytes); i++) {
|
|
snprintf(md5sum_str + 2 * i, sizeof(md5sum_str) - 2 * i,
|
|
"%02x", md5sum->bytes[i]);
|
|
}
|
|
|
|
str_printf(&desc, "ICCv%f %s %s", cmsGetProfileVersion(profile),
|
|
name_part, md5sum_str);
|
|
|
|
return desc;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Build stock profile which available for clients unaware of color management
|
|
*/
|
|
bool
|
|
cmlcms_create_stock_profile(struct weston_color_manager_lcms *cm)
|
|
{
|
|
cmsHPROFILE profile;
|
|
struct cmlcms_md5_sum md5sum;
|
|
char *desc = NULL;
|
|
|
|
profile = cmsCreate_sRGBProfileTHR(cm->lcms_ctx);
|
|
if (!profile) {
|
|
weston_log("color-lcms: error: cmsCreate_sRGBProfileTHR failed\n");
|
|
return false;
|
|
}
|
|
if (!cmsMD5computeID(profile)) {
|
|
weston_log("Failed to compute MD5 for ICC profile\n");
|
|
goto err_close;
|
|
}
|
|
|
|
cmsGetHeaderProfileID(profile, md5sum.bytes);
|
|
desc = make_icc_file_description(profile, &md5sum, "sRGB stock");
|
|
if (!desc)
|
|
goto err_close;
|
|
|
|
cm->sRGB_profile = cmlcms_color_profile_create(cm, profile, desc, NULL);
|
|
if (!cm->sRGB_profile)
|
|
goto err_close;
|
|
|
|
if (!retrieve_eotf_and_output_inv_eotf(cm->lcms_ctx,
|
|
cm->sRGB_profile->profile,
|
|
cm->sRGB_profile->output_eotf,
|
|
cm->sRGB_profile->output_inv_eotf_vcgt,
|
|
cm->sRGB_profile->vcgt,
|
|
cmlcms_reasonable_1D_points()))
|
|
goto err_close;
|
|
|
|
return true;
|
|
|
|
err_close:
|
|
free(desc);
|
|
cmsCloseProfile(profile);
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
cmlcms_get_color_profile_from_icc(struct weston_color_manager *cm_base,
|
|
const void *icc_data,
|
|
size_t icc_len,
|
|
const char *name_part,
|
|
struct weston_color_profile **cprof_out,
|
|
char **errmsg)
|
|
{
|
|
struct weston_color_manager_lcms *cm = get_cmlcms(cm_base);
|
|
cmsHPROFILE profile;
|
|
struct cmlcms_md5_sum md5sum;
|
|
struct cmlcms_color_profile *cprof;
|
|
char *desc = NULL;
|
|
|
|
if (!icc_data || icc_len < 1) {
|
|
str_printf(errmsg, "No ICC data.");
|
|
return false;
|
|
}
|
|
if (icc_len >= UINT32_MAX) {
|
|
str_printf(errmsg, "Too much ICC data.");
|
|
return false;
|
|
}
|
|
|
|
profile = cmsOpenProfileFromMemTHR(cm->lcms_ctx, icc_data, icc_len);
|
|
if (!profile) {
|
|
str_printf(errmsg, "ICC data not understood.");
|
|
return false;
|
|
}
|
|
|
|
if (!validate_icc_profile(profile, errmsg))
|
|
goto err_close;
|
|
|
|
if (!cmsMD5computeID(profile)) {
|
|
str_printf(errmsg, "Failed to compute MD5 for ICC profile.");
|
|
goto err_close;
|
|
}
|
|
|
|
cmsGetHeaderProfileID(profile, md5sum.bytes);
|
|
cprof = cmlcms_find_color_profile_by_md5(cm, &md5sum);
|
|
if (cprof) {
|
|
*cprof_out = weston_color_profile_ref(&cprof->base);
|
|
cmsCloseProfile(profile);
|
|
return true;
|
|
}
|
|
|
|
desc = make_icc_file_description(profile, &md5sum, name_part);
|
|
if (!desc)
|
|
goto err_close;
|
|
|
|
cprof = cmlcms_color_profile_create(cm, profile, desc, errmsg);
|
|
if (!cprof)
|
|
goto err_close;
|
|
|
|
*cprof_out = &cprof->base;
|
|
return true;
|
|
|
|
err_close:
|
|
free(desc);
|
|
cmsCloseProfile(profile);
|
|
return false;
|
|
}
|
|
|
|
void
|
|
cmlcms_destroy_color_profile(struct weston_color_profile *cprof_base)
|
|
{
|
|
struct cmlcms_color_profile *cprof = get_cprof(cprof_base);
|
|
|
|
cmlcms_color_profile_destroy(cprof);
|
|
}
|
|
|