# Babl-0.1.52

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-06-02 babl-0.1.52
  Concurrency fixes and fixes to handling of 0/1 entry palettes, do not pre-equalize XYZ conversion matrices for sRGB, internal clean-ups, pre-define ACES2065-1 and ACEScg BablSpaces, add R~G~B~ set of spaces, which for all BablSpaces mean use sRGB TRC.
2018-05-20 babl-0.1.50
  Improvements to speed and precision of indexed code, improvements to meson build.
2018-05-15 babl-0.1.48
  fix u8 <-> double conversions for chroma, SSE2 version of RGBA float to CIE L / Lab. Build with -Ofast by default.
2018-04-10 babl-0.1.46
  added extensions with more coverage for u32, half and other utilit fast paths improving fast path coverage.
2018-02-18 babl-0.1.44
  Fix bug in custom primaries/ICC fast paths, improve meson build
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~

components

  R~
  G~
  B~

R'G'B'A

components

  R'
  G'
  B'
  A

R~G~B~A

components

  R~
  G~
  B~
  A

R'aG'aB'aA

components

  R'a
  G'a
  B'a
  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~

components

  Y~

Y~A

components

  Y~
  A

Y'CbCr

components

  Y'
  Cb
  Cr

Y'CbCrA

components

  Y'
  Cb
  Cr
  A

Y'CbCr709

components

  Y'
  Cb
  Cr

Y'CbCrA709

components

  Y'
  Cb
  Cr
  alpha

HCYA

components

  hue
  HCY chroma
  HCY luma
  alpha

HCY

components

  hue
  HCY chroma
  HCY luma

HSVA

components

  hue
  saturation
  value
  alpha

HSV

components

  hue
  saturation
  value

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

HSLA

components

  hue
  saturation
  lightness
  alpha

HSL

components

  hue
  saturation
  lightness

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~ 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~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~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' 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

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

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

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

Y~ double

bytes/pixel
  8
model
  Y~
components

  double | Y~

Y~A double

bytes/pixel
  16
model
  Y~A
components

  double | Y~
  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'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 float

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

  float | R~a
  float | G~a
  float | B~a
  float | A

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 float

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

  float | R~
  float | G~
  float | B~
  float | A

R'G'B' float

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

  float | R'
  float | G'
  float | B'

R~G~B~ float

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

  float | R~
  float | G~
  float | B~

Y' float

bytes/pixel
  4
model
  Y'
components

  float | Y'

Y~ float

bytes/pixel
  4
model
  Y~
components

  float | Y~

Y'A float

bytes/pixel
  8
model
  Y'A
components

  float | Y'
  float | A

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

RaGaBaA float

bytes/pixel
  16
model
  RaGaBaA
components

  float | Ra
  float | Ga
  float | Ba
  float | A

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

Y~ half

bytes/pixel
  2
model
  Y~
components

  half | Y~

Y~A half

bytes/pixel
  4
model
  Y~A
components

  half | Y~
  half | 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~aG~aB~aA u8

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

  u8 | R~a
  u8 | G~a
  u8 | B~a
  u8 | A

Y' u8

bytes/pixel
  1
model
  Y'
components

  u8 | Y'

Y~ u8

bytes/pixel
  1
model
  Y~
components

  u8 | Y~

Y'A u8

bytes/pixel
  2
model
  Y'A
components

  u8 | Y'
  u8 | A

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

RGBA u8

bytes/pixel
  4
model
  RGBA
components

  u8 | R
  u8 | G
  u8 | B
  u8 | A

RGB u8

bytes/pixel
  3
model
  RGB
components

  u8 | R
  u8 | G
  u8 | B

RaGaBaA u8

bytes/pixel
  4
model
  RaGaBaA
components

  u8 | Ra
  u8 | Ga
  u8 | Ba
  u8 | A

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

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 u16

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

  u16 | R~a
  u16 | G~a
  u16 | B~a
  u16 | A

R'G'B'A u16

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

  u16 | R'
  u16 | G'
  u16 | B'
  u16 | A

R~G~B~A u16

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

  u16 | R~
  u16 | G~
  u16 | B~
  u16 | A

R'G'B' u16

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

  u16 | R'
  u16 | G'
  u16 | B'

R~G~B~ u16

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

  u16 | R~
  u16 | G~
  u16 | B~

Y' u16

bytes/pixel
  2
model
  Y'
components

  u16 | Y'

Y~ u16

bytes/pixel
  2
model
  Y~
components

  u16 | Y~

Y'A u16

bytes/pixel
  4
model
  Y'A
components

  u16 | Y'
  u16 | A

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

RGBA u16

bytes/pixel
  8
model
  RGBA
components

  u16 | R
  u16 | G
  u16 | B
  u16 | A

RGB u16

bytes/pixel
  6
model
  RGB
components

  u16 | R
  u16 | G
  u16 | B

RaGaBaA u16

bytes/pixel
  8
model
  RaGaBaA
components

  u16 | Ra
  u16 | Ga
  u16 | Ba
  u16 | A

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

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'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

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

cairo-ARGB32

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

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

cairo-RGB24

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

  u8 | B'
  u8 | G'
  u8 | R'
  u8 | PAD

cairo-A8

bytes/pixel
  1
model
  YA
components

  u8 | 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

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

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

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

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

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

## 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
Félix Piédallu
  Initial meson build