Babl-0.1.42

Contents

  • Babl
  •   Features
  • Download
  • Documentation
  •   Usage
  •   Vocabulary
  •   Shortcut Coverage
  •   Environment
  •   Extending
  •   Directory Overview
  • Todo
  • Copyright
  •   Authors


babl is a dynamic, any to any, pixel format translation library.

It allows converting between different methods of storing pixels known
as pixel formats that have with different bitdepths and other data
representations, color models, color spaces and component permutations.

A vocabulary to formulate new pixel formats from existing primitives is
provided as well as the framework to add new color models, spaces and
data types.

Features

  • ANSI C without external dependencies, works on win32, linux and
    mac, 32bit and 64bit systems.
  • Stable, small API, with singleton objects returned.
  • Extendable with new formats, color models, components and
    datatypes.
  • Can load color spaces from ICC v2 and v4 profiles containing RGB
    matrix + TRC.
  • Reference 64bit floating point conversions for datatypes and color
    models.
  • Self profiling and optimizing, optimizing accuracy and performance
    at runtime when the best performing single or multi-step conversion
    path is chosen.

GEGL through GeglBuffer provides tiled buffers with on disk storage as
well as linear buffers with accessor functions for efficient data
access transparently using babl fishes for translation to the desired
pixel formats.

Download

The latest versioned development version of babl can be found in https:
//download.gimp.org/pub/babl/.

Babl uses git. The main repository is hosted by GNOME. It can be
browsed online and cloned with:

git clone git://git.gnome.org/babl

NEWS

The following is a list of the major changes that have gone into each
babl release. If there are significant improvements to babl when a GEGL
release is done a babl release is most often put out just prior to the
GEGL release.

2018-01-23 babl-0.1.42
    Fully initialize fishes when loading from cache.
2018-01-16 babl-0.1.40
    Added format "CIE XYZ alpha" color model and formats. New API
    babl_process_rows for reduced overhead in some scenarios; though
    bigger gains seen also for regular babl_process with reimplemented
    branch-free dispatch, and faster cbrt. Added meson build; being
    tested in parallel with auotmake, Improved reference conversions
    for formats skipping some of models components, Fixed gamma
    handling in indexed/palettized formats and improved gamma precision
    consistenct in sse2 conversions.
2017-11-15 babl-0.1.38
    Added format "CIE L float", a couple of protections against
    division by 0.0
2017-11-10 babl-0.1.36
    Optimized customized primary aware code paths for CIE Lab<->RGB
    conversions, improved accuracy of gamma approximations. New API
    babl_format_exists() for checking validity of babl format name,
    crash proofing of cache handling and use of environment variables.
2017-10-06 babl-0.1.34
    Brown paper bag release, Fix indexed / custom primaries conflict,
    and re-export a symbol used by old GEGL/GIMPs.
2017-10-03 babl-0.1.32
    Added custom primaries and TRC support through ICC parsing,
    improved float<->half performance, rewrite of all conversions
    functions to adhere to new signature.
2017-07-15 babl-0.1.30
    Thread stability for palette modes, stricter alpha preservation,
    now cross-compilable on android.
2017-05-30 babl-0.1.28
    Fast paths for Lav <-> Lch, release triggered by pending GIMP
    release.
2017-05-09 babl-0.1.26
    Build and install HCY color space, platform independences fixes to
    fish cache.
2017-02-01 babl-0.1.24
    Improvements to profile cache persistance, fast paths that improve
    actual GIMP use on various precisions, use single precision
    constants for some more of CIE computions.
2016-11-05 babl-0.1.22
    Added cache of profiled conversions, added HCY color model, some
    precision and performance updated for fast paths.
2016-11-05 babl-0.1.20
    Fix run-time errors, leaks, and race conditions. Add conditional
    fast paths.
2016-06-13 babl-0.1.18
    Bugfix: take alpha threshold in consideration when processing
    floats in SSE2.
2016-02-12 babl-0.1.16
    Improvements to half float reference, SIMD, and fast-paths, and CIE
    float fast paths; cleanups of fast path extensions.
2015-11-19 babl-0.1.14
    sRGB precision tuning, stability fixes, locale fix for setting
    error tolerance.
2015-02-03 babl-0.1.12
    optimizations for floating point conversions, HSV and HSL color
    models, removal of dead code, fixed CIE Lab conversions.
2012-03-30 babl-0.1.10
    LUT based speedups for gamma correction / uncorrection.
2012-03-30 babl-0.1.8
    Added support for indexed/pallette based formats, constified API.
2011-11-18 babl-0.1.6
    Build improvements, remove blatantly wrong conversions from
    extensions, made it possible to distinguish format_n formats from
    others, improvements to vala/gobject introspection support.
2011-01-20 babl-0.1.4
    Improved cross platform build ability, added code to handle
    n-component formats, remove extraenous runtime profiling that
    impacted performance.
2010-01-15 babl-0.1.2
    Made babl mostly threadsafe (sufficient for GIMP/GEGLs needs).
    Streamlined core functionality, reducing number of function calls
    and removing overeager instrumentation.
2009-05-20 babl-0.1.0
    Support for RGBA representation in the frequency domain,
    un-pre-multiply close-to-zero alpha values to complete black
    instead of slightly brighter than black, add a BABL_ALPHA_THRESHOLD
    constant to the API, do a complete overhaul of the babl API and do
    some changes to increase portability of the library.
2008-06-12 babl-0.0.22
    Speed improvements due to: coalesced hashing, early bail out upon
    creation of duplicate formats, caching of non existing paths. Large
    amounts of the core has also been reviewed and refactored. Improved
    conversion coverage in the matrix.
2008-02-27 babl-0.0.20
    Builds on OSX Check <0.0 and >1.0 values conversions for accuracy
    as well.

For more news see git log.

Documentation

When using BablFishes to do your conversions, you request a fish to
convert between two formats, and an optimal fish to babls capability is
provided that you can use to do your conversions. Babl also provides
the capability to describe new formats based on a vocabulary of user
registered color models and data types.

Babl provides a base vocabulary in BablBase and some extensions that
are thought to be generally useful.

When performing further extensions to the vocabulary of babl, the
internal consistency is governed by reference conversions that operate
on double (64 bit floating point values). The only color model created
during BablCore bootstrap is RGBA (linear light RGB, 0.0 - 1.0, with a
linear 0.0 - 1.0 opacity channel) backed by the double datatype.
Defined similarily to scRGB using 64bit floating point.

If babls conversion isn't fast enough, you can provide your own
conversion shortcut between two formats. The registered shortcut might
also be used by babl as an intermediate conversion when constructing
BablFishes for other conversions.

Babl extensions are shared objects. If you have already developed some
fast conversion functions, wrapping them as babl extensions should not
take much time and will speed up babl for other users as well.

Usage

babl_process (babl_fish (source_format, destination_format),
              source_buffer, destination_buffer,
              pixel_count);

The processing operation that babl performs is copying including
conversions if needed between linear buffers containing the same count
of pixels, with different pixel formats.

int width = 123, height = 581, pixel_count = width * height;

const Babl *srgb             = babl_format ("R'G'B' u8");
const Babl *lab              = babl_format ("CIE Lab float");
const Babl *srgb_to_lab_fish = babl_fish (srgb, lab);

float         *lab_buffer;
unsigned char *srgb_buffer;

babl_init ();

srgb_buffer = malloc (pixel_count * babl_format_get_bytes_per_pixel (srgb));
lab_buffer  = malloc (pixel_count * 3 * sizeof (float));

...... load data into srgb_buffer .......

babl_process (srgb_to_lab_fish, srgb_buffer, lab_buffer, pixel_count);

...... do operation in lab space ........

babl_process (babl_fish(lab, srgb),
              lab_buffer, srgb_buffer, pixel_count);

/* the data has now been transformed back to srgb data */

If the existing pixel formats are not sufficient for your conversion
needs, new ones can be created on the fly. The constructor will provide
the prior created one if duplicates are registered.

const Babl *format = babl_format_new (babl_model ("R'G'B'"),
                                      babl_type ("u16"),
                                      babl_component ("B'"),
                                      babl_component ("G'"),
                                      babl_component ("R'"),
                                      NULL);

Color Management

By default the babl API is assuming data to be (unbounded) sRGB data,
data being sRGB defines the conversion to and from gray-scale as well
as the gamma - or Transfer Response Curve, TRC, used for converting
between linear and non-linear variants of the data.

There is also a babl API call for creating a format for a specific
space. babl_format_with_space("R'G'B' u16", babl_space ("Rec2020"))
creates a 16 bit integer format for the Rec2020 color space. Babl knows
internally about "sRGB", "Rec2020", "Adobe", "Apple" and "ProPhoto"
spaces, as they are defined with constants on their wikipedia pages.

Additional spaces can be loaded from monitor-class matrix+TRC ICC v2
and v4 profiles. Using babl_icc_make_space (see babl.h for details).
The space of a babl format can also be queried with
babl_format_get_space.

The conversions babl does with ICC profiles are according to what is
known as the relative-colorimetric intent, monitor profiles containing
both the matrices used by babl and 3d CLUTs (color look up tables) most
often also do relative-colorimetric transfer for the "perceptual"
intent CLUTs, but with a more flexible and possibly higher accuracy
conversions. If babl adds support for loading and using CLUTs it will
be thus the perceptual intent will by babl be considered a different
albeit more accurate relative-colorimetric RGB space.

Vocabulary


+-
Data types
double

bits
    64
bytes
    8

u15

bits
    16
bytes
    2

half

bits
    16
bytes
    2

float

bits
    32
bytes
    4

u8

bits
    8
bytes
    1

u8-luma

bits
    8
bytes
    1

u8-chroma

bits
    8
bytes
    1

u16

bits
    16
bytes
    2

u32

bits
    32
bytes
    4

CIE u8 L

bits
    8
bytes
    1

CIE u8 ab

bits
    8
bytes
    1

CIE u16 L

bits
    16
bytes
    2

CIE u16 ab

bits
    16
bytes
    2

Color models
RGBA

components

    R
    G
    B
    A

RGB

components

    R
    G
    B

RaGaBaA

components

    Ra
    Ga
    Ba
    A

R'G'B'

components

    R'
    G'
    B'

R'G'B'A

components

    R'
    G'
    B'
    A

R'aG'aB'aA

components

    R'a
    G'a
    B'a
    A

Y

components

    Y

YA

components

    Y
    A

YaA

components

    Ya
    A

Y'

components

    Y'

Y'A

components

    Y'
    A

Y'aA

components

    Y'a
    A

Y'CbCr

components

    Y'
    Cb
    Cr

Y'CbCrA

components

    Y'
    Cb
    Cr
    A

CIE Lab

components

    CIE L
    CIE a
    CIE b

CIE Lab alpha

components

    CIE L
    CIE a
    CIE b
    A

CIE LCH(ab)

components

    CIE L
    CIE C(ab)
    CIE H(ab)

CIE LCH(ab) alpha

components

    CIE L
    CIE C(ab)
    CIE H(ab)
    A

CIE XYZ

components

    CIE X
    CIE Y
    CIE Z

CIE XYZ alpha

components

    CIE X
    CIE Y
    CIE Z
    A

HCYA

components

    hue
    HCY chroma
    HCY luma
    alpha

HCY

components

    hue
    HCY chroma
    HCY luma

HSLA

components

    hue
    saturation
    lightness
    alpha

HSL

components

    hue
    saturation
    lightness

Y'CbCr709

components

    Y'
    Cb
    Cr

Y'CbCrA709

components

    Y'
    Cb
    Cr
    alpha

HSVA

components

    hue
    saturation
    value
    alpha

HSV

components

    hue
    saturation
    value

CMYK

components

    cyan
    magenta
    yellow
    key

CMY

components

    cyan
    magenta
    yellow

Pixel formats
RGBA double

bytes/pixel
    32
model
    RGBA
components

    double  R
    double  G
    double  B
    double  A

RGB double

bytes/pixel
    24
model
    RGB
components

    double  R
    double  G
    double  B

RaGaBaA double

bytes/pixel
    32
model
    RaGaBaA
components

    double  Ra
    double  Ga
    double  Ba
    double  A

R'G'B' double

bytes/pixel
    24
model
    R'G'B'
components

    double  R'
    double  G'
    double  B'

R'G'B'A double

bytes/pixel
    32
model
    R'G'B'A
components

    double  R'
    double  G'
    double  B'
    double  A

R'aG'aB'aA double

bytes/pixel
    32
model
    R'aG'aB'aA
components

    double  R'a
    double  G'a
    double  B'a
    double  A

R'G'B' u8

bytes/pixel
    3
model
    R'G'B'
components

    u8 R'
    u8 G'
    u8 B'

R'G'B'A u8

bytes/pixel
    4
model
    R'G'B'A
components

    u8 R'
    u8 G'
    u8 B'
    u8 A

RGBA float

bytes/pixel
    16
model
    RGBA
components

    float  R
    float  G
    float  B
    float  A

RGB float

bytes/pixel
    12
model
    RGB
components

    float  R
    float  G
    float  B

RGB half

bytes/pixel
    6
model
    RGB
components

    half  R
    half  G
    half  B

RGBA half

bytes/pixel
    8
model
    RGBA
components

    half  R
    half  G
    half  B
    half  A

RaGaBaA half

bytes/pixel
    8
model
    RaGaBaA
components

    half  Ra
    half  Ga
    half  Ba
    half  A

R'G'B' half

bytes/pixel
    6
model
    R'G'B'
components

    half  R'
    half  G'
    half  B'

R'G'B'A half

bytes/pixel
    8
model
    R'G'B'A
components

    half  R'
    half  G'
    half  B'
    half  A

R'aG'aB'aA half

bytes/pixel
    8
model
    R'aG'aB'aA
components

    half  R'a
    half  G'a
    half  B'a
    half  A

RGB u15

bytes/pixel
    6
model
    RGB
components

    u15  R
    u15  G
    u15  B

RGBA u15

bytes/pixel
    8
model
    RGBA
components

    u15  R
    u15  G
    u15  B
    u15  A

RaGaBaA u15

bytes/pixel
    8
model
    RaGaBaA
components

    u15  Ra
    u15  Ga
    u15  Ba
    u15  A

R'G'B' u15

bytes/pixel
    6
model
    R'G'B'
components

    u15  R'
    u15  G'
    u15  B'

R'G'B'A u15

bytes/pixel
    8
model
    R'G'B'A
components

    u15  R'
    u15  G'
    u15  B'
    u15  A

R'aG'aB'aA u15

bytes/pixel
    8
model
    R'aG'aB'aA
components

    u15 R'a
    u15 G'a
    u15 B'a
    u15 A

RGB u32

bytes/pixel
    12
model
    RGB
components

    u32  R
    u32  G
    u32  B

RGBA u32

bytes/pixel
    16
model
    RGBA
components

    u32  R
    u32  G
    u32  B
    u32  A

RaGaBaA u32

bytes/pixel
    16
model
    RaGaBaA
components

    u32  Ra
    u32  Ga
    u32  Ba
    u32  A

R'G'B' u32

bytes/pixel
    12
model
    R'G'B'
components

    u32  R'
    u32  G'
    u32  B'

R'G'B'A u32

bytes/pixel
    16
model
    R'G'B'A
components

    u32  R'
    u32  G'
    u32  B'
    u32  A

R'aG'aB'aA u32

bytes/pixel
    16
model
    R'aG'aB'aA
components

    u32 R'a
    u32 G'a
    u32 B'a
    u32 A

Y double

bytes/pixel
    8
model
    Y
components

    double  Y

YA double

bytes/pixel
    16
model
    YA
components

    double  Y
    double  A

YaA double

bytes/pixel
    16
model
    YaA
components

    double  Ya
    double  A

Y' double

bytes/pixel
    8
model
    Y'
components

    double  Y'

Y'A double

bytes/pixel
    16
model
    Y'A
components

    double  Y'
    double  A

Y'aA double

bytes/pixel
    16
model
    Y'aA
components

    double  Y'a
    double  A

YA half

bytes/pixel
    4
model
    YA
components

    half  Y
    half  A

YaA half

bytes/pixel
    4
model
    YaA
components

    half  Ya
    half  A

Y half

bytes/pixel
    2
model
    Y
components

    half  Y

Y'A half

bytes/pixel
    4
model
    Y'A
components

    half  Y'
    half  A

Y'aA half

bytes/pixel
    4
model
    Y'aA
components

    half  Y'a
    half  A

Y' half

bytes/pixel
    2
model
    Y'
components

    half  Y'

YA u15

bytes/pixel
    4
model
    YA
components

    u15  Y
    u15  A

YaA u15

bytes/pixel
    4
model
    YaA
components

    u15  Ya
    u15  A

Y u15

bytes/pixel
    2
model
    Y
components

    u15  Y

Y'A u15

bytes/pixel
    4
model
    Y'A
components

    u15  Y'
    u15  A

Y'aA u15

bytes/pixel
    4
model
    Y'aA
components

    u15 Y'a
    u15 A

Y' u15

bytes/pixel
    2
model
    Y'
components

    u15  Y'

YA u32

bytes/pixel
    8
model
    YA
components

    u32  Y
    u32  A

YaA u32

bytes/pixel
    8
model
    YaA
components

    u32  Ya
    u32  A

Y u32

bytes/pixel
    4
model
    Y
components

    u32  Y

Y'A u32

bytes/pixel
    8
model
    Y'A
components

    u32  Y'
    u32  A

Y'aA u32

bytes/pixel
    8
model
    Y'aA
components

    u32 Y'a
    u32 A

Y' u32

bytes/pixel
    4
model
    Y'
components

    u32  Y'

Y'CbCr double

bytes/pixel
    24
model
    Y'CbCr
components

    double  Y'
    double  Cb
    double  Cr

Y'CbCrA double

bytes/pixel
    32
model
    Y'CbCrA
components

    double  Y'
    double  Cb
    double  Cr
    double  A

Y'CbCr u8

bytes/pixel
    3
model
    Y'CbCr
components

    u8-luma    Y'
    u8-chroma  Cb
    u8-chroma  Cr

R'G'B'A float

bytes/pixel
    16
model
    R'G'B'A
components

    float  R'
    float  G'
    float  B'
    float  A

R'G'B'A u16

bytes/pixel
    8
model
    R'G'B'A
components

    u16  R'
    u16  G'
    u16  B'
    u16  A

R'aG'aB'aA float

bytes/pixel
    16
model
    R'aG'aB'aA
components

    float  R'a
    float  G'a
    float  B'a
    float  A

R'aG'aB'aA u16

bytes/pixel
    8
model
    R'aG'aB'aA
components

    u16 R'a
    u16 G'a
    u16 B'a
    u16 A

R'aG'aB'aA u8

bytes/pixel
    4
model
    R'aG'aB'aA
components

    u8 R'a
    u8 G'a
    u8 B'a
    u8 A

R'G'B' float

bytes/pixel
    12
model
    R'G'B'
components

    float  R'
    float  G'
    float  B'

R'G'B' u16

bytes/pixel
    6
model
    R'G'B'
components

    u16  R'
    u16  G'
    u16  B'

Y'A float

bytes/pixel
    8
model
    Y'A
components

    float  Y'
    float  A

Y'aA float

bytes/pixel
    8
model
    Y'aA
components

    float  Y'a
    float  A

Y' float

bytes/pixel
    4
model
    Y'
components

    float  Y'

Y'A u16

bytes/pixel
    4
model
    Y'A
components

    u16  Y'
    u16  A

Y'aA u16

bytes/pixel
    4
model
    Y'aA
components

    u16 Y'a
    u16 A

Y' u16

bytes/pixel
    2
model
    Y'
components

    u16  Y'

Y'A u8

bytes/pixel
    2
model
    Y'A
components

    u8 Y'
    u8 A

Y'aA u8

bytes/pixel
    2
model
    Y'aA
components

    u8 Y'a
    u8 A

Y' u8

bytes/pixel
    1
model
    Y'
components

    u8 Y'

Y'CbCr float

bytes/pixel
    12
model
    Y'CbCr
components

    float  Y'
    float  Cb
    float  Cr

Y'CbCrA float

bytes/pixel
    16
model
    Y'CbCrA
components

    float  Y'
    float  Cb
    float  Cr
    float  A

RGBA u16

bytes/pixel
    8
model
    RGBA
components

    u16  R
    u16  G
    u16  B
    u16  A

RGBA u8

bytes/pixel
    4
model
    RGBA
components

    u8  R
    u8  G
    u8  B
    u8  A

RaGaBaA float

bytes/pixel
    16
model
    RaGaBaA
components

    float  Ra
    float  Ga
    float  Ba
    float  A

RaGaBaA u16

bytes/pixel
    8
model
    RaGaBaA
components

    u16  Ra
    u16  Ga
    u16  Ba
    u16  A

RaGaBaA u8

bytes/pixel
    4
model
    RaGaBaA
components

    u8 Ra
    u8 Ga
    u8 Ba
    u8 A

RGB u16

bytes/pixel
    6
model
    RGB
components

    u16  R
    u16  G
    u16  B

RGB u8

bytes/pixel
    3
model
    RGB
components

    u8  R
    u8  G
    u8  B

YA float

bytes/pixel
    8
model
    YA
components

    float  Y
    float  A

YaA float

bytes/pixel
    8
model
    YaA
components

    float  Ya
    float  A

Y float

bytes/pixel
    4
model
    Y
components

    float  Y

YA u16

bytes/pixel
    4
model
    YA
components

    u16  Y
    u16  A

YaA u16

bytes/pixel
    4
model
    YaA
components

    u16  Ya
    u16  A

Y u16

bytes/pixel
    2
model
    Y
components

    u16  Y

YA u8

bytes/pixel
    2
model
    YA
components

    u8  Y
    u8  A

YaA u8

bytes/pixel
    2
model
    YaA
components

    u8 Ya
    u8 A

Y u8

bytes/pixel
    1
model
    Y
components

    u8  Y

cairo-RGB24

bytes/pixel
    4
model
    R'G'B'
components

    u8 B'
    u8 G'
    u8 R'
    u8 PAD

CIE Lab double

bytes/pixel
    24
model
    CIE Lab
components

    double  CIE L
    double  CIE a
    double  CIE b

CIE Lab alpha double

bytes/pixel
    32
model
    CIE Lab alpha
components

    double  CIE L
    double  CIE a
    double  CIE b
    double  A

CIE LCH(ab) double

bytes/pixel
    24
model
    CIE LCH(ab)
components

    double CIE L
    double CIE C(ab)
    double CIE H(ab)

CIE LCH(ab) alpha double

bytes/pixel
    32
model
    CIE LCH(ab) alpha
components

    double CIE L
    double CIE C(ab)
    double CIE H(ab)
    double A

CIE XYZ double

bytes/pixel
    24
model
    CIE XYZ
components

    double  CIE X
    double  CIE Y
    double  CIE Z

CIE XYZ alpha double

bytes/pixel
    32
model
    CIE XYZ alpha
components

    double  CIE X
    double  CIE Y
    double  CIE Z
    double  A

CIE Lab float

bytes/pixel
    12
model
    CIE Lab
components

    float CIE L
    float CIE a
    float CIE b

CIE XYZ float

bytes/pixel
    12
model
    CIE XYZ
components

    float CIE X
    float CIE Y
    float CIE Z

CIE XYZ alpha float

bytes/pixel
    16
model
    CIE XYZ
components

    float CIE X
    float CIE Y
    float CIE Z
    float A

CIE Lab alpha float

bytes/pixel
    16
model
    CIE Lab alpha
components

    float CIE L
    float CIE a
    float CIE b
    float A

CIE L float

bytes/pixel
    4
model
    CIE Lab
components

    float CIE L

CIE L alpha float

bytes/pixel
    8
model
    CIE Lab alpha
components

    float CIE L
    float A

CIE Lab u8

bytes/pixel
    3
model
    CIE Lab
components

    CIE u8 L   CIE L
    CIE u8 ab  CIE a
    CIE u8 ab  CIE b

CIE Lab u16

bytes/pixel
    6
model
    CIE Lab
components

    CIE u16 L   CIE L
    CIE u16 ab  CIE a
    CIE u16 ab  CIE b

CIE LCH(ab) float

bytes/pixel
    12
model
    CIE LCH(ab)
components

    float CIE L
    float CIE C(ab)
    float CIE H(ab)

CIE LCH(ab) alpha float

bytes/pixel
    16
model
    CIE LCH(ab) alpha
components

    float CIE L
    float CIE C(ab)
    float CIE H(ab)
    float A

HCYA double

bytes/pixel
    32
model
    HCYA
components

    double hue
    double HCY chroma
    double HCY luma
    double alpha

HCY double

bytes/pixel
    24
model
    HCY
components

    double hue
    double HCY chroma
    double HCY luma

HCYA float

bytes/pixel
    16
model
    HCYA
components

    float hue
    float HCY chroma
    float HCY luma
    float alpha

HCY float

bytes/pixel
    12
model
    HCY
components

    float hue
    float HCY chroma
    float HCY luma

B'aG'aR'aA u8

bytes/pixel
    4
model
    R'aG'aB'aA
components

    u8 B'a
    u8 G'a
    u8 R'a
    u8 A

HSLA double

bytes/pixel
    32
model
    HSLA
components

    double hue
    double saturation
    double lightness
    double alpha

HSL double

bytes/pixel
    24
model
    HSL
components

    double hue
    double saturation
    double lightness

HSLA float

bytes/pixel
    16
model
    HSLA
components

    float hue
    float saturation
    float lightness
    float alpha

HSL float

bytes/pixel
    12
model
    HSL
components

    float hue
    float saturation
    float lightness

cairo-ARGB32

bytes/pixel
    4
model
    R'aG'aB'aA
components

    u8 B'a
    u8 G'a
    u8 R'a
    u8 A

cairo-A8

bytes/pixel
    1
model
    YA
components

    u8  A

Y'CbCr709 double

bytes/pixel
    24
model
    Y'CbCr709
components

    double  Y'
    double  Cb
    double  Cr

Y'CbCrA709 double

bytes/pixel
    32
model
    Y'CbCrA709
components

    double  Y'
    double  Cb
    double  Cr
    double  alpha

Y'CbCrA709 float

bytes/pixel
    16
model
    Y'CbCrA709
components

    float Y'
    float Cb
    float Cr
    float alpha

Y'CbCr709 float

bytes/pixel
    12
model
    Y'CbCr709
components

    float  Y'
    float  Cb
    float  Cr

HSVA double

bytes/pixel
    32
model
    HSVA
components

    double hue
    double saturation
    double value
    double alpha

HSV double

bytes/pixel
    24
model
    HSV
components

    double hue
    double saturation
    double value

HSVA float

bytes/pixel
    16
model
    HSVA
components

    float hue
    float saturation
    float value
    float alpha

HSV float

bytes/pixel
    12
model
    HSV
components

    float hue
    float saturation
    float value

CMYK double

bytes/pixel
    32
model
    CMYK
components

    double cyan
    double magenta
    double yellow
    double key

CMY double

bytes/pixel
    24
model
    CMY
components

    double cyan
    double magenta
    double yellow

CMYK float

bytes/pixel
    16
model
    CMYK
components

    float cyan
    float magenta
    float yellow
    float key

CMY float

bytes/pixel
    12
model
    CMY
components

    float cyan
    float magenta
    float yellow

CMYK u8

bytes/pixel
    4
model
    CMYK
components

    u8 cyan
    u8 magenta
    u8 yellow
    u8 key

Shortcut Coverage

The diagram shown below visualizes the coverage of current shortcut
conversions. Dots indicate a direct conversion is provided for, the
height of the bar indicates the number of conversions steps needed in a
chain of conversions.

Environment

Through the environment variable BABL_TOLERANCE you can control a speed
/performance trade off that by default is set very low (0.000001)
values in the range 0.01-0.1 can provide reasonable preview performance
by allowing lower numerical accuracy

.

BABL_PATH contains the path of the directory, containing the .so
extensions to babl.

Extending

For samples of how the current internal API specification of data
types, color models, and conversions look in the extensions/ directory.
The tables in this HTML file is directly generated based on the data
registered by BablCore (double and RGBA), BablBase (core datatypes, and
RGB models), extensions (CIE Lab, naive CMYK, various shortcut
conversions).

Directory Overview

babl-dist-root
 │
 ├──babl       the babl core
 │   └──base   reference implementations for RGB and Grayscale Color Models,
 │             8bit 16bit, and 32bit and 64bit floating point.
 ├──extensions CIE-Lab color model as well as a naive-CMYK color model.
 │             also contains a random cribbage of old conversion optimized
 │             code from gggl. Finding more exsisting conversions in third
 │             part libraries (hermes, lcms?, liboil?) could improve the
 │             speed of babl.
 ├──tests      tests used to keep babl sane during development.
 └──docs       Documentation/webpage for babl (the document you are reading
               originated there.

TODO

  • Support for conversions between formats that have higher
    dimensionality than RGBA.
  • Support for datatypes that are not a multiple of 8bit.

Copyright

Babl is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the
Free Software Foundation; either version 3 of the License, or (at your
option) any later version.

Authors

Øyvind Kolås pippin at gimp.org
    Original author.
Sven Neumann sven at gimp.org
    Build sanity and optimizations.
Michael Natterer mitch at gimp.org
    Build sanity.
Kevin Cozens kcozens at cvs.gnome.org
    Build sanity.
Tim Mooney
    Portability fixes.
Michael Schumacher schumaml at cvs.gnome.org
    win32 support for dynamic extensions.
    Portability fixes.
Jan Heller jheller at svn.gnome.org
    Optimizations, refactoring and documentation.
Mukund Sivaraman muks at mukund.org
    Sparse fixes and sanity.
dmacks at netspace.org
    Build sanity
Sam Hocevar
    Build sanity.
Zhang Junbo
    Frequency domain color model.
Martin Nordholts
    Optimizations and API overhaul.
Gary V. Vaughan
    Multiplatform build support.
Stanislav Brabec
    Portability patch.
Hubert Figuiere
    C++ friendliness patch.
Danny Robson
    Code cleanups.
Fryderyk Dziarmagowski freetz at gmx.net
    Code cleanups.
Daniel Paredes García danipga at gmail.com
    Initial work to make babl threadsafe
Rupert Weber gimp at leguanease.org
    Documentation and other improvements
Jehan jehan at girinstud.io
    win32 portabilitiy
Sven Claussner
    Update DOAP file
Alexander Larsson
    Math optimizations
Nils Philippsen
    code cleanups
Simon Budig
    cleanups
Micheal Muré
    portability fixes
Edward E
    win32 platform adaptations
Maxime Nicco

    HSV color model extension

Teo Mazars
    Color spaces/models in extensions
Daniel Sabo
    Dead code elimination, general cleanups,
Michael Henning
    Conversion fixes
Elle Stone
    Verification and improvements to accuracy of color space
    conversions.
Thomas Manni
    CIE related fixups
Roman Lebedev
    Stability/crasher fixes
Jon Nordby
    Portability, Stability and more
Massimo Valentini
    stability fixes
Ell
    fast paths

/babl-0.1.42
