sse2-float: don't modify input data during rgba -> rgbA conversion

NEWS: update news for 0.1.58 release

docs: add section about premultiplied alpha

babl-fish-reference: add lock to part of float reference

This fixes problems that occur during GEGLs documentation gallery build
when multiple threads are in use (the default). The critical section has
experimentally been made as short as possible to avoid babl memory
inconsistencies - without identifing the core race.

babl: babl_free now complains and bail instead of aborting on unknown memory

babl: remove more missing fast path warnings

We no longer want to warn, since warnings are also triggered when the
fast path is better than the best path found, something that happens
when we-re finding long paths and the reference is better.

Maybe we should still print warnings according to better heuristics to be able
to warn and encourage complete fast path coverage, fast paths should still be
able to beat the reference in a few steps.

babl-fish-reference: factor out separate function for float/double

babl_fish_reference_process now only contains the dispatch tree that
tries various fast paths first before ending up in the float or double
synthetic references.

base: model-gray: remove special case for black transparent premul

babl: switch behavior of reference precision enum

It is now called BABL_REFERENCE_NOFLOAT and if set babl is not using the
generic mechanism to synthesize many possible float<->float conversions.

Revert "special case all 0 to map to all 0 in nonpremul"

This reverts commit 18dea5104f3de79af5e9641a0ef47435b112d44b.

We want to be able to do component by component average/weighting of
remultiplied values, by breaking the floor for black alpha zero we
break the consistency of such arithmetic.

tools: fix utf8 mode of diagram, change gradient unit in html

The gradient in the html mode is now pixels per time, not bytes
read+written per time, which seem to be more fair in assessing
the reference conversions of
different pixel sizes.

babl-fish-reference: escape to double when single is too hard

If we do not have the conversions for to/from RGBA float - bail as early as
possible to the double code path instead.

babl-fish: handle case of no from_list in source

base: fix misregistred Y float to RGBA float conversion

base: use f suffix on float literals

base: more single precision code paths for model-rgb

babl-fish-reference: disable a fast-code path that sometimes is invalid

base: register a RGBA to RGBA float conversion for completeness

extensions: implement Labf_to_rgbaf

base: add single precision versions of all gray reference code

base: model-rgb add float version of conversions for RaGaBaA

base: model-rgb implement float versions of some conversions

babl-fish-reference: implement floating point version of reference path

This relies on conversions, linear or planar, being registered to and from
RGBA float, similar to the already existing reference conversions in double.

To enable use of it set the environment variable BABL_REFERENCE_FLOAT to any
value, babl will crash if the above requirement is not met for a requested
conversion - permitting adding it - fallback code could be added that implements
it using the double versions when missing - but not having a full coverage at
least for the commonly used formats defeats the purpose.

babl: skip initial profiling for planar conversions

babl-fish-reference: avoid converting model if it already is RGBA

babl-matrix: add babl_matrix_mul_matrixf

babl-fish-reference: also do non-component matching same model in single precision

babl-fish-reference: reintroduce single precision processing

only for matching components for now

babl: silence missing path warning

babl-fish-reference: improve component match checking for same-model

revert parts of fd2f96c53d9

Some of it was a bit too immature to commit, a reworked version will be
repushed.

special case all 0 to map to all 0 in nonpremul

A test in GEGL relies on this, and keeping zeroed memory zeroed is good
for compression and some other heuristics that might run on a buffer.

babl-fish-reference: do some conversions in single precision float

This permits these conversions to go through floating point instead of double
precision when non of the involved format have more than 32bit precision,
this might be determinetal to u32 but is right for u8 and u16 which we rely
most on.

We also disable the missing fast path messages, since now many references;
through internal shortcuts are faster than some long chains, perhaps some
of these reference fast paths should be split out as new categories of fishes.

base: register single precision conversions for types

We're already registering double versions, having single precision and
in practice possibly sufficient precision for commonly used conversions.

tools/babl_fish_path_fitness: fix text only version

tools: improve html output of babl_fish_path_fitness

Illustrate memory throughput as read+writte/time, providing a metric that
works for comparing conversions against each other on a single machine.

babl: move BABL_ALPHA_FLOOR to public babl header

extensions: handle negative premultiplied alpha

babl: model-rgb handle negative alpha in premultiplied

babl: model-rgb, handle negative alpha in premultiplied

extensions: adapt to keep color in premultiplied alpha

base: preserve color in premutiplied alpha

Alpha values below BABL_ALPHA_FLOOR gets stored in the components
as BABL_ALPHA_FLOOR with alpha also set to BABL_ALPHA_FLOOR,
recovery from pre-multiplied to non-premultiplied is done as normal.
BABL_FLOOR is set to be 1/65536.0 with a hope that this gives us
approximately 8bit of color data preserved when using half-float.

Upon encountering exactly BABL_ALPHA_FLOOR in premultiplied conversion
to non-premultiplied interprets this as 0.0, making pure 0.0 values
round trip correctly from RGBA to RaGaBaA back to RGBA.

This makes a lot of extensions invalid - as expected but it already
allows testing the behavior of GEGL and GIMP with this additional
feature from babl.

babl: add performance flag to intent, issue #21

Add BABL_ICC_INTENT_PERFORMANCE which can be ored into the intente
num when requesting that babl constructs a space using
babl_space_from_icc, when PERFORMANCE is requested babl will permit
matrix+trc over cLUT, and when it is an intent without a performance
modifier this does not apply.

icc: detect inconsistent Argyll ICC cLUT profiles, issue #21

The default behavior for Agryll when creating cLUT profiles seem to be
embedding an obviously incorrect XYZ matrix, meaning that for now we cannot use
the matrix for our relative colorimetric transform, and in the future the
profile will be incapable of doing dynamic trade-offs between performance and
accuracy by using matrix over cLUT during interactive operations.

We detect the swapped primaries in combination with presence of cLUTs and then
bail on constructing a valid babl space, as well as provide debug information
about why the profile cannot be used by babl.

post release version bump

release 0.1.56

babl-cache: store reference fishes in the cache

When we only have a reference fish for a given conversion, and not
a path fish, store a corresponding entry in the cache, marked by a
"[reference]" tag in the fish's attributes line, and containing no
conversion list.  When reloading the cache, make sure a reference
fish is created for the conversion without trying to construct a
path fish, so that we don't waste time trying to search for a
conversion path.

Note that we still show a "missing fast path" warning, even for
cached reference fishes.

babl-cache: skip fishes with nonexistent conversions, instead of bailing

When encountering a nonexistent conversion while loading the fish
cache, skip the current fish, instead of stopping processing the
cache entirely.

post release version bump

release 0.1.54

NEWS: update

babl.h: tidy and update documentation

meson: Generate babl.map based on export_symbols file

Fixing issue #20

Signed-off-by: Jan Vesely <jano.vesely@gmail.com>

babl: use an existing const char ptr for encoding in format

babl: add a new symbol babl_format_get_encoding

This returns the string passed in to babl_format_new - without the space
suffix that babl_get_name does for non-sRGB formats.

babl: add babl_space_with_trc

Permitting to create variants of a space that shared the primaries
but use a different TRC function.

Add SSE2 versions of "Y float" and "YA float" to "CIE L float"

babl: simplify babl_format_with_space

Rely on any format string containing the substring "-space" that this
substring is the marker for the end of the encoding part of the format
name - which is what we want replicated in our new format with a different
color space.

babl: permit Babl * as first argument of babl_format_with_space

babl: harmonize naming of space constructors

babl_icc_make_space remains for compatibility so older versions of gimp
do not get upset, the gimp-2.10 release depends on this symbol.

babl: look deeper, and longer for path fishes

We now do two iterations of +1 and +2 path lengths that take much longer than
the configured path lengths - and now complain with a debug output listing the
set of conversions taken to satisfy the request - giving hints on what parts
could possibly be shortened to fewer steps.

With this commit the first level of searching deeper also gets a debug message
which would cause GIMP to print a message in some places where it earlier
wouldnt have warned about missing fast paths.

babl: allow querying chromaticities for spaces made with matrix

Do this by computing the chromaticities coordinates of the colors
.. #ff0000 #00ff00 and #0000ff, this also harmonizes the serialized
name to always be chromaticities, white point and trcs.

extensions/u32: add ~ model/format support

extensions/u16; add ~ model/format support

extensions/float: add ~ variants of conversions

Change the license URL from http://www.gnu.org/licenses/ to https://

babl: add babl_model_is, utility function for checking model equivalence

This creates an on the fly model with the same space as the one compared with
and does pointer equivalence. Using it makes for less verbose code.

babl: make babl_model_with_space able to take format/model for space

babl.h: add documentation

babl: make equalize_matrix argument an enum

babl: make babl_space_to_icc symbol internal

babl-space: add comments, do not use a static temp struct

babl: add babl_space_get_icc

babl: simplify the singleton logic in babl_format_with_space

babl: export symbol model_with_space

babl: add babl_space_get

An accessor for getting back out the chromaticities of whitepoint and primaries
as well as trcs.

babl: add separate LUTs for rTRC,gTRC and bTRC in generic fast paths

babl: fix bug in icc tag alignment

babl: export symbol babl_space_to_icc

babl: export more symbols

Adding babl_chromaticities_make_space, babl_trc and
babl_trc_gamma to public api and ability to setup arbitrary
BablSpaces without loading from ICC profiles.

extensions/two-table: temporarily disable

When viewing PNGs with attached ICC profiles the gegl binary produces black
if the two-table extension is active. Something is wrong in babl even accepting
these paths.

Drop newlines between tags

post-release version bump

release 0.1.52

export-symbols: export babl_trc

NEWS: update

babl-palette: fix default palette double-data size

babl: fix trc registrationof ACES spaces

babl: predefine ACEScg and ACES2065-1 BablSpaces

tests: add format_with_space test

Testing that both R'G'B' formats and CIE Lab float keep the space they have
been created with.

babl: refactor format registration to loop over types

Also register full set of R~G~B~ and Y~ formats for all the types.

babl: add ~ variants to gray color models

We do not add premultiplied sRGB trc variants even if this exists for RGB
since it is the type of premultiplied alpha cairo expects. The less code
that does non-linear compositing the better, excluding some possibilities
also reduces the combinatorial overhead of finding conversion paths in babl.

babl: add R~G~B~ color models and pixel formats

From a given BablSpace which defines RGB chromaticities and
per component TRCs, the following are the defined formats:

R'G'B' with the TRCs applied
RGB    linear data

and now a new one

R~G~B~ with the sRGB TRC, this permits any BablSpace to be the
native format of a buffer in an application while having both
a 'perceptual' in R~G~B~ and linear in RGB that is possible
to derive from it. Importantly it is also possible to recover
the babl space used to create the buffer.

babl: clarify internal gray babl-id enums

Use GRAY_LINEAR and GRAY_NONLINEAR making the introduction of PERCEPTUAL
easier.

babl: remove outdated comment

babl: rename functions that used to refer to specific gamma

The definitions of components and formats for linear and nonlinear formats in
model-rgb and model-gray are now using the TRC of a BablSpace, thus in the
format syntax ' now means nonlinear, not sRGB / 2.2 gamma - even though it ends
up meaning that for formats create without specifying the space.

babl-palette: warn when trying to create a palette with > 256 colors

... and only use the first 256 colors.

babl-fish: fix concurrent babl_fish()/process() calls with palette formats

In babl_fish(), don't call _babl_fish_rig_dispatch() on existing
path fishes during each lookup.  We already call this function on
all path fishes upon creation (in particular, after commit
b34a9672c8c9a42923a8f0b2650af30b1efe635c), so this isn't necessary.

This fixes an issue where the _babl_fish_rig_dispatch() call in
babl_fish() would temporarily modify the value of babl->fish.data,
causing a concurrent babl_process[_rows]() call in another thread
to pass the wrong 'data' value down to the conversion function.  In
particular, this could cause palette conversions to segfault.

babl: fix fixed to double conversions

See issue #18 https://gitlab.gnome.org/GNOME/babl/issues/18

babl-space: babl_space_new_from_chromaticities add equalize_matrix argument

Part of the problem in issue #18

This API is internal only for now so we can change it, changing to use a
hard-coded pre-quantized chromaticities set for the internal sRGB space.

This preserve the gray axis matrix equalization performed for other spaces used
with babl, ideally we can improve the gray-axis equalization to match and
return to using it also for sRGB.