diff --git a/include/libweston/linalg-3.h b/include/libweston/linalg-3.h index 2fe2ec698..2310e48fe 100644 --- a/include/libweston/linalg-3.h +++ b/include/libweston/linalg-3.h @@ -30,6 +30,7 @@ extern "C" { #endif #include +#include #include #include @@ -95,6 +96,37 @@ weston_v3f_dot_v3f(struct weston_vec3f a, struct weston_vec3f b) return a.x * b.x + a.y * b.y + a.z * b.z; } +/** + * Convert an array of vec3f into planar format + * + * Takes an array of RGB triplets and converts it into a planar format where all R + * values come first, then all G values, then all B values. + * + * \param planar The destination array for planar data, must have space for 3 * len floats + * \param arr Array of RGB triplets as vec3f structs + * \param len Number of RGB triplets in the array + */ +static inline void +weston_v3f_array_to_planar(float *planar, const struct weston_vec3f *arr, size_t len) +{ + size_t i; + + for (i = 0; i < len; i++) { + planar[i ] = arr[i].r; + planar[i + len] = arr[i].g; + planar[i + 2 * len] = arr[i].b; + } +} + +/** Clamp each element to the range [a, b], replacing NaN with a. */ +static inline struct weston_vec3f +weston_v3f_clamp(struct weston_vec3f v, float a, float b) +{ + return WESTON_VEC3F(v.x >= a ? (v.x <= b ? v.x : b) : a, + v.y >= a ? (v.y <= b ? v.y : b) : a, + v.z >= a ? (v.z <= b ? v.z : b) : a); +} + /** * Matrix infinity-norm * diff --git a/libweston/color-operations.c b/libweston/color-operations.c index 47b96a436..cf03f9680 100644 --- a/libweston/color-operations.c +++ b/libweston/color-operations.c @@ -32,21 +32,6 @@ #include "shared/helpers.h" #include "shared/weston-assert.h" -/** - * Clamp value to [0.0, 1.0], except pass NaN through. - * - * This function is not intended for hiding NaN. - */ -static float -ensure_unorm(float v) -{ - if (v <= 0.0f) - return 0.0f; - if (v > 1.0f) - return 1.0f; - return v; -} - static float linpow(float x, const union weston_color_curve_parametric_chan_data *p) { @@ -61,18 +46,21 @@ linpow(float x, const union weston_color_curve_parametric_chan_data *p) } static void -sample_linpow(const union weston_color_curve_parametric_chan_data *p, - uint32_t len, bool clamp_input, float *in, float *out) +sample_linpow(const union weston_color_curve_parametric_data *p, + bool clamp_input, const struct weston_vec3f *in, + struct weston_vec3f *out, size_t len) { - float x; - unsigned int i; + struct weston_vec3f tmp; + size_t i; for (i = 0; i < len; i++) { - x = in[i]; + tmp = in[i]; if (clamp_input) - x = ensure_unorm(x); + tmp = weston_v3f_clamp(tmp, 0.0f, 1.0f); - out[i] = linpow(x, p); + out[i] = WESTON_VEC3F(linpow(tmp.x, &p->chan[0]), + linpow(tmp.y, &p->chan[1]), + linpow(tmp.z, &p->chan[2])); } } @@ -90,21 +78,43 @@ powlin(float x, const union weston_color_curve_parametric_chan_data *p) } static void -sample_powlin(const union weston_color_curve_parametric_chan_data *p, - uint32_t len, bool clamp_input, float *in, float *out) +sample_powlin(const union weston_color_curve_parametric_data *p, + bool clamp_input, const struct weston_vec3f *in, + struct weston_vec3f *out, size_t len) { - float x; - unsigned int i; + struct weston_vec3f tmp; + size_t i; for (i = 0; i < len; i++) { - x = in[i]; + tmp = in[i]; if (clamp_input) - x = ensure_unorm(x); + tmp = weston_v3f_clamp(tmp, 0.0f, 1.0f); - out[i] = powlin(x, p); + out[i] = WESTON_VEC3F(powlin(tmp.x, &p->chan[0]), + powlin(tmp.y, &p->chan[1]), + powlin(tmp.z, &p->chan[2])); } } +static void +sample_parametric(struct weston_compositor *compositor, + const struct weston_color_curve_parametric *param, + const struct weston_vec3f *in, + struct weston_vec3f *out, + size_t len) +{ + switch (param->type) { + case WESTON_COLOR_CURVE_PARAMETRIC_TYPE_LINPOW: + sample_linpow(¶m->params, param->clamped_input, in, out, len); + return; + case WESTON_COLOR_CURVE_PARAMETRIC_TYPE_POWLIN: + sample_powlin(¶m->params, param->clamped_input, in, out, len); + return; + } + + weston_assert_not_reached(compositor, "unknown parametric color curve"); +} + static float perceptual_quantizer(float x) { @@ -142,44 +152,52 @@ perceptual_quantizer_inverse(float x) } static void -sample_pq(enum weston_tf_direction tf_direction, uint32_t ch, uint32_t len, - float *in, float *out) +sample_pq(enum weston_tf_direction tf_direction, + const struct weston_vec3f *in, + struct weston_vec3f *out, + size_t len) { - unsigned int i; - float x; + struct weston_vec3f tmp; + size_t i; - for (i = 0; i < len; i++) { - /** - * PQ and inverse PQ are always clamped, undefined for values - * out of [0, 1] range. - */ - x = ensure_unorm(in[i]); - - if (tf_direction == WESTON_FORWARD_TF) - out[i] = perceptual_quantizer(x); - else - out[i] = perceptual_quantizer_inverse(x); + switch (tf_direction) { + case WESTON_FORWARD_TF: + for (i = 0; i < len; i++) { + tmp = weston_v3f_clamp(in[i], 0.0f, 1.0f); + out[i] = WESTON_VEC3F(perceptual_quantizer(tmp.x), + perceptual_quantizer(tmp.y), + perceptual_quantizer(tmp.z)); + } + break; + case WESTON_INVERSE_TF: + for (i = 0; i < len; i++) { + tmp = weston_v3f_clamp(in[i], 0.0f, 1.0f); + out[i] = WESTON_VEC3F(perceptual_quantizer_inverse(tmp.x), + perceptual_quantizer_inverse(tmp.y), + perceptual_quantizer_inverse(tmp.z)); + } + break; } } /** -* Given a color curve and a channel, sample an input. -* -* This handles the parametric curves (LINPOW, POWLIN, etc) and enumerated color -* curves. Others should result in failure. -* -* @param compositor The Weston compositor -* @param curve The color curve to be used to sample -* @param ch The curve color channel to sample from -* @param len The in and out arrays length -* @param in The input array to sample -* @param out The resulting array from sampling -* @returns True on success, false otherwise -*/ -bool + * Evaluate a color curve on an array + * + * This handles the parametric curves (LINPOW, POWLIN, etc) and enumerated color + * curves. Others result in failure. + * + * @param compositor The Weston compositor + * @param curve The color curve to evaluate + * @param in The input array of length @c len . + * @param out The output array of length @c len . + * @param len The in and out arrays' length. + */ +void weston_color_curve_sample(struct weston_compositor *compositor, struct weston_color_curve *curve, - uint32_t ch, uint32_t len, float *in, float *out) + const struct weston_vec3f *in, + struct weston_vec3f *out, + size_t len) { struct weston_color_curve_parametric parametric; bool ret; @@ -193,20 +211,19 @@ weston_color_curve_sample(struct weston_compositor *compositor, */ switch (curve->u.enumerated.tf.info->tf) { case WESTON_TF_ST2084_PQ: - sample_pq(curve->u.enumerated.tf_direction, ch, len, in, out); - return true; + sample_pq(curve->u.enumerated.tf_direction, in, out, len); + return; default: ret = weston_color_curve_enum_get_parametric(compositor, &curve->u.enumerated, ¶metric); - if (!ret) - return false; - goto param; + weston_assert_true(compositor, ret); + sample_parametric(compositor, ¶metric, in, out, len); + return; } case WESTON_COLOR_CURVE_TYPE_PARAMETRIC: - /* Parametric curve, let's copy it and we'll handle that below. */ - parametric = curve->u.parametric; - goto param; + sample_parametric(compositor, &curve->u.parametric, in, out, len); + return; case WESTON_COLOR_CURVE_TYPE_IDENTITY: weston_assert_not_reached(compositor, "no need to sample identity"); @@ -216,19 +233,4 @@ weston_color_curve_sample(struct weston_compositor *compositor, } weston_assert_not_reached(compositor, "unknown color curve"); - -param: - /* Sample from parametric curves. */ - switch (parametric.type) { - case WESTON_COLOR_CURVE_PARAMETRIC_TYPE_LINPOW: - sample_linpow(¶metric.params.chan[ch], - len, parametric.clamped_input, in, out); - return true; - case WESTON_COLOR_CURVE_PARAMETRIC_TYPE_POWLIN: - sample_powlin(¶metric.params.chan[ch], - len, parametric.clamped_input, in, out); - return true; - } - - weston_assert_not_reached(compositor, "unknown parametric color curve"); } diff --git a/libweston/color-operations.h b/libweston/color-operations.h index b332035c5..96febfca2 100644 --- a/libweston/color-operations.h +++ b/libweston/color-operations.h @@ -27,10 +27,15 @@ #define WESTON_COLOR_OPERATIONS_H #include +#include -bool +#include "color.h" + +void weston_color_curve_sample(struct weston_compositor *compositor, struct weston_color_curve *curve, - uint32_t ch, uint32_t len, float *in, float *out); + const struct weston_vec3f *in, + struct weston_vec3f *out, + size_t len); #endif /* WESTON_COLOR_OPERATIONS_H */ diff --git a/libweston/color.c b/libweston/color.c index 13e65df34..d2da16e00 100644 --- a/libweston/color.c +++ b/libweston/color.c @@ -354,9 +354,9 @@ weston_color_curve_to_3x1D_LUT(struct weston_compositor *compositor, struct weston_color_curve *curve; float divider = lut_size - 1; const char *step_str; - float *in, *lut; - unsigned int i, ch; - bool ret; + float *lut; + struct weston_vec3f *tmp; + unsigned int i; switch(step) { case WESTON_COLOR_CURVE_STEP_PRE: @@ -389,30 +389,30 @@ weston_color_curve_to_3x1D_LUT(struct weston_compositor *compositor, "result in bad precision\n", xform->id, step_str); } + lut = calloc(lut_size, 3 * sizeof *lut); + tmp = calloc(lut_size, sizeof *tmp); + if (!lut || !tmp) { + /* lut_size could be big. */ + free(lut); + free(tmp); + str_printf(err_msg, "Out of memory"); + return NULL; + } + switch(curve->type) { case WESTON_COLOR_CURVE_TYPE_LUT_3x1D: - lut = xzalloc(3 * lut_size * sizeof(*lut)); curve->u.lut_3x1d.fill_in(xform, lut, lut_size); + free(tmp); return lut; case WESTON_COLOR_CURVE_TYPE_ENUM: case WESTON_COLOR_CURVE_TYPE_PARAMETRIC: - lut = xzalloc(3 * lut_size * sizeof(*lut)); - in = xzalloc(lut_size * sizeof(*lut)); - for (i = 0; i < lut_size; i++) - in[i] = (float)i / divider; - for (ch = 0; ch < 3; ch++) { - ret = weston_color_curve_sample(compositor, curve, ch, lut_size, - in, &lut[ch * lut_size]); - if (!ret) { - free(lut); - lut = NULL; - str_printf(err_msg, "can't create color LUT from xform (id %u) " \ - "%s-curve, failed to sample color curve", - xform->id, step_str); - break; - } + for (i = 0; i < lut_size; i++) { + float x = (float)i / divider; + tmp[i] = WESTON_VEC3F(x, x, x); } - free(in); + weston_color_curve_sample(compositor, curve, tmp, tmp, lut_size); + weston_v3f_array_to_planar(lut, tmp, lut_size); + free(tmp); return lut; case WESTON_COLOR_CURVE_TYPE_IDENTITY: weston_assert_not_reached(compositor,