Illusion/pdf-odin-llm
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

initial commit

Browse Source
This commit is contained in:
Illusion
2026-09-25 23:32:29 +02:00
commit fff8b677f8
114 changed files with 84233 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
colorspace.odin
+866
View File
@@ -0,0 +1,866 @@
package pdf
import "core:math"
// Colour spaces (ISO 32000-2, 8.6).
//
// Every space is reduced to RGB for output. That is not colour management and
// does not pretend to be: an ICCBased space renders through its /Alternate (or
// through the device space its /N implies), which is what every
// non-colour-managed viewer does and what the format explicitly permits.
Colorspace_Kind :: enum u8 {
Device_Gray,
Device_RGB,
Device_CMYK,
Cal_Gray,
Cal_RGB,
Lab,
ICC_Based,
Indexed,
Separation,
Device_N,
Pattern,
}
Colorspace :: struct {
kind: Colorspace_Kind,
// Components a colour value in this space carries. 1 for Indexed (the
// index itself), not the base space's count.
n: int,
name: string,
// Indexed: `base` is the space the lookup table's entries live in, and
// `lookup` holds (hival+1) * base.n bytes.
base: ^Colorspace,
lookup: []byte,
hival: int,
// Separation, DeviceN and ICCBased all render through `alt`. For the first
// two, `tint` maps the colorant values into it.
alt: ^Colorspace,
tint: ^Function,
colorant_names: []string,
// The /None colorant marks nothing at all on the page (8.6.6.4).
is_none: bool,
// The /All colorant marks every separation.
is_all: bool,
// CalGray, CalRGB and Lab.
white_point: [3]f64,
black_point: [3]f64,
gamma: [3]f64,
// CalRGB's /Matrix. For a Lab space this holds something else the caller
// never sees: the 3x3 that takes XYZ under this space's own white point to
// linear sRGB, chromatic adaptation folded in, computed once at load time
// so that converting a colour is nine multiplies and no matrix building.
mtx: [9]f64,
// Lab's a and b component ranges, defaulting to [-100 100 -100 100].
range: [4]f64,
// Pattern's underlying space, present only for an uncoloured tiling
// pattern, whose colour is supplied by the content that paints it.
under: ^Colorspace,
}
// Nesting of colour spaces: an Indexed whose base is a Separation whose
// alternate is an ICCBased, and so on. Four is the deepest anything
// meaningful goes; the limit exists because /Resources can be made to name a
// space that names itself.
@(private)
MAX_COLORSPACE_DEPTH :: 8
// The most entries an Indexed lookup table can address. /HiVal is capped at
// 255 by the format (8.6.6.3), which is what makes an index a single byte.
@(private)
MAX_INDEXED_HIVAL :: 255
// ---------------------------------------------------------------------------
// The device spaces
//
// These are shared, immutable and outlive every Document: they hold no
// document memory and nothing ever writes to them, so handing the same pointer
// to two Documents (or to two threads rendering different files) is safe. It
// also means the overwhelmingly common `/DeviceRGB cs` costs nothing at all.
// ---------------------------------------------------------------------------
@(private)
cs_gray := Colorspace{kind = .Device_Gray, n = 1, name = "DeviceGray"}
@(private)
cs_rgb := Colorspace{kind = .Device_RGB, n = 3, name = "DeviceRGB"}
@(private)
cs_cmyk := Colorspace{kind = .Device_CMYK, n = 4, name = "DeviceCMYK"}
// A /Pattern space with no underlying space: the pattern carries its own
// colour, so a colour value in it has no components at all. `n` is therefore
// 0, not 1 -- `n` is what tells the content interpreter how many numeric
// operands `scn` takes, and a coloured pattern is set with `/P1 scn`, a name
// and nothing else. An uncoloured pattern is the case with components, and it
// gets them from its underlying space in cs_load_pattern.
@(private)
cs_pattern := Colorspace{kind = .Pattern, n = 0, name = "Pattern"}
colorspace_device_gray :: proc(doc: ^Document) -> ^Colorspace {
return &cs_gray
}
colorspace_device_rgb :: proc(doc: ^Document) -> ^Colorspace {
return &cs_rgb
}
colorspace_device_cmyk :: proc(doc: ^Document) -> ^Colorspace {
return &cs_cmyk
}
// colorspace_device_n returns the device space with `n` components, which is
// how an ICCBased space with no /Alternate and an inline image with no space
// at all are resolved (8.6.5.5).
@(private)
colorspace_device_n :: proc(n: int) -> ^Colorspace {
switch n {
case 1: return &cs_gray
case 4: return &cs_cmyk
}
return &cs_rgb
}
// ---------------------------------------------------------------------------
// Loading
// ---------------------------------------------------------------------------
// colorspace_load builds the colour space `obj` names or describes.
//
// `res` is the /Resources dictionary of the page or form whose content stream
// named it, and is where a bare name that is not a device space is looked up
// (through /Resources /ColorSpace); it may be nil, and a caller that has only
// the /ColorSpace sub-dictionary may pass that instead.
//
// The result is owned by the Document and must not be freed. Spaces are cached
// by the object they were built from, because a page that names the same space
// in four hundred XObjects must build it once.
colorspace_load :: proc(doc: ^Document, obj: Object, res: ^Dict) -> (^Colorspace, Error) {
return cs_load(doc, obj, res, 0)
}
@(private)
cs_load :: proc(doc: ^Document, obj: Object, res: ^Dict, depth: int) -> (^Colorspace, Error) {
if doc == nil {
return nil, .Invalid_Argument
}
if depth > MAX_COLORSPACE_DEPTH {
add_repair(doc, .Recursion_Limit_Hit, 0)
return nil, .Recursion_Limit
}
o := resolve(doc, obj)
key := object_identity(o)
if key != 0 {
if cached, ok := doc.cs_cache[key]; ok {
return cached, .None
}
}
cs: ^Colorspace
err := Error.Bad_Colorspace
#partial switch v in o {
case Name:
cs, err = cs_load_name(doc, string(v), res, depth)
case ^Array:
cs, err = cs_load_array(doc, v, res, depth)
}
if err != .None || cs == nil {
return nil, err == .None ? .Bad_Colorspace : err
}
if key != 0 {
if doc.cs_cache == nil {
doc.cs_cache = make(map[uintptr]^Colorspace, 16, doc.allocator)
}
doc.cs_cache[key] = cs
}
return cs, .None
}
@(private)
cs_load_name :: proc(doc: ^Document, name: string, res: ^Dict, depth: int) -> (^Colorspace, Error) {
// The device spaces cannot be redefined by a resource dictionary
// (8.6.3), so they are answered before it is consulted.
switch name {
case "DeviceGray": return &cs_gray, .None
case "DeviceRGB": return &cs_rgb, .None
case "DeviceCMYK": return &cs_cmyk, .None
case "Pattern": return &cs_pattern, .None
}
if res != nil {
// `res` is the /Resources dictionary, so a name is looked up in its
// /ColorSpace sub-dictionary (8.6.3). A caller holding only that
// sub-dictionary may pass it instead: it is tried second, so it cannot
// shadow a genuine /ColorSpace entry.
if csdict := dict_dict(doc, res, "ColorSpace"); csdict != nil {
if entry := dict_get_raw(csdict, name); entry != nil {
return cs_load(doc, entry, res, depth + 1)
}
}
if entry := dict_get_raw(res, name); entry != nil {
return cs_load(doc, entry, res, depth + 1)
}
}
// The inline-image abbreviations (Table 93). They are only legal inside an
// inline image dictionary, so they are tried after the resource lookup: a
// resource genuinely called /G has to win.
switch name {
case "G": return &cs_gray, .None
case "RGB": return &cs_rgb, .None
case "CMYK": return &cs_cmyk, .None
}
return nil, .Bad_Colorspace
}
@(private)
cs_load_array :: proc(doc: ^Document, a: ^Array, res: ^Dict, depth: int) -> (^Colorspace, Error) {
if array_len(a) == 0 {
return nil, .Bad_Colorspace
}
family := array_name(doc, a, 0)
// `[/DeviceRGB]` and `[/Pattern]` are both legal spellings.
if array_len(a) == 1 {
return cs_load_name(doc, family, res, depth)
}
switch family {
case "DeviceGray", "G": return &cs_gray, .None
case "DeviceRGB", "RGB": return &cs_rgb, .None
case "DeviceCMYK", "CMYK": return &cs_cmyk, .None
case "CalGray": return cs_load_calgray(doc, a)
case "CalRGB": return cs_load_calrgb(doc, a)
case "Lab": return cs_load_lab(doc, a)
case "ICCBased": return cs_load_icc(doc, a, res, depth)
case "Indexed", "I": return cs_load_indexed(doc, a, res, depth)
case "Separation": return cs_load_separation(doc, a, res, depth)
case "DeviceN": return cs_load_devicen(doc, a, res, depth)
case "Pattern": return cs_load_pattern(doc, a, res, depth)
}
return nil, .Bad_Colorspace
}
@(private)
cs_new :: proc(doc: ^Document, kind: Colorspace_Kind, n: int, name: string) -> ^Colorspace {
cs := new(Colorspace, doc.allocator)
cs.kind = kind
cs.n = n
cs.name = name
cs.white_point = {0.9642, 1.0, 0.8249} // D50, the format's own default
cs.gamma = {1, 1, 1}
cs.range = {-100, 100, -100, 100}
return cs
}
// cs_read_white_point reads /WhitePoint, which must be a positive XYZ triple
// with Y = 1. A file that gives something else gets D50, because a zero or
// negative component divides by zero further down.
@(private)
cs_read_white_point :: proc(doc: ^Document, d: ^Dict, cs: ^Colorspace) {
wp := dict_array(doc, d, "WhitePoint")
if array_len(wp) < 3 {
return
}
x := clamp_finite(array_num(doc, wp, 0, 0), 0)
y := clamp_finite(array_num(doc, wp, 1, 0), 0)
z := clamp_finite(array_num(doc, wp, 2, 0), 0)
if x <= 0 || y <= 0 || z <= 0 {
add_repair(doc, .Bad_Resource, 0)
return
}
cs.white_point = {x, y, z}
bp := dict_array(doc, d, "BlackPoint")
if array_len(bp) >= 3 {
cs.black_point = {
clamp_finite(array_num(doc, bp, 0, 0), 0),
clamp_finite(array_num(doc, bp, 1, 0), 0),
clamp_finite(array_num(doc, bp, 2, 0), 0),
}
}
}
@(private)
cs_load_calgray :: proc(doc: ^Document, a: ^Array) -> (^Colorspace, Error) {
d := array_dict(doc, a, 1)
cs := cs_new(doc, .Cal_Gray, 1, "CalGray")
cs_read_white_point(doc, d, cs)
g := clamp_finite(dict_num(doc, d, "Gamma", 1), 1)
if g <= 0 {
g = 1
}
cs.gamma = {g, g, g}
return cs, .None
}
@(private)
cs_load_calrgb :: proc(doc: ^Document, a: ^Array) -> (^Colorspace, Error) {
d := array_dict(doc, a, 1)
cs := cs_new(doc, .Cal_RGB, 3, "CalRGB")
cs_read_white_point(doc, d, cs)
if ga := dict_array(doc, d, "Gamma"); array_len(ga) >= 3 {
for i in 0 ..< 3 {
g := clamp_finite(array_num(doc, ga, i, 1), 1)
cs.gamma[i] = g > 0 ? g : 1
}
}
if ma := dict_array(doc, d, "Matrix"); array_len(ma) >= 9 {
for i in 0 ..< 9 {
cs.mtx[i] = clamp_finite(array_num(doc, ma, i, 0), 0)
}
}
return cs, .None
}
@(private)
cs_load_lab :: proc(doc: ^Document, a: ^Array) -> (^Colorspace, Error) {
d := array_dict(doc, a, 1)
cs := cs_new(doc, .Lab, 3, "Lab")
cs_read_white_point(doc, d, cs)
if r := dict_array(doc, d, "Range"); array_len(r) >= 4 {
for i in 0 ..< 4 {
cs.range[i] = clamp_finite(array_num(doc, r, i, 0), 0)
}
// An inverted range would clamp every value to nothing.
if cs.range[0] > cs.range[1] {
cs.range[0], cs.range[1] = cs.range[1], cs.range[0]
}
if cs.range[2] > cs.range[3] {
cs.range[2], cs.range[3] = cs.range[3], cs.range[2]
}
}
cs.mtx = lab_to_srgb_matrix(cs.white_point)
return cs, .None
}
@(private)
cs_load_icc :: proc(doc: ^Document, a: ^Array, res: ^Dict, depth: int) -> (^Colorspace, Error) {
stm := to_stream(array_get(doc, a, 1)) or_else nil
d, _ := to_dict(array_get(doc, a, 1))
n := int(dict_int(doc, d, "N", 0))
if n != 1 && n != 3 && n != 4 {
n = 0
}
alt: ^Colorspace
if entry := dict_get_raw(d, "Alternate"); entry != nil {
loaded, err := cs_load(doc, entry, res, depth + 1)
if err == .None && loaded != nil && loaded.kind != .Pattern {
// An /Alternate that disagrees with /N is the file contradicting
// itself; /N is what the sample data is laid out by.
if n == 0 || loaded.n == n {
alt = loaded
}
}
}
if alt == nil {
if n == 0 {
// Neither /N nor a usable /Alternate. The profile itself would say,
// but reading ICC profiles is exactly what this library does not
// do, so the commonest case is assumed.
add_repair(doc, .Bad_Resource, 0, stm != nil ? stm.ref : Ref{})
n = 3
}
alt = colorspace_device_n(n)
}
// Rendering happens entirely through the alternate: no ICC profile is ever
// parsed and no colour management is performed. Every non-colour-managed
// viewer does the same, and 8.6.5.5 allows it.
cs := cs_new(doc, .ICC_Based, alt.n, "ICCBased")
cs.alt = alt
return cs, .None
}
@(private)
cs_load_indexed :: proc(doc: ^Document, a: ^Array, res: ^Dict, depth: int) -> (^Colorspace, Error) {
base, berr := cs_load(doc, array_get_raw(a, 1), res, depth + 1)
if berr != .None || base == nil {
return nil, .Bad_Colorspace
}
// The base of an Indexed space may not itself be Indexed or Pattern
// (8.6.6.3); either would make an index mean nothing.
if base.kind == .Indexed || base.kind == .Pattern {
return nil, .Bad_Colorspace
}
cs := cs_new(doc, .Indexed, 1, "Indexed")
cs.base = base
cs.hival = int(clamp(array_int(doc, a, 2, 0), 0, MAX_INDEXED_HIVAL))
lookup := array_get(doc, a, 3)
#partial switch v in lookup {
case String:
cs.lookup = transmute([]byte)v
case ^Stream:
data, derr := stream_data(doc, v)
if derr == .None {
cs.lookup = data
}
}
if len(cs.lookup) < (cs.hival + 1) * base.n {
// A short table is common in files that were subset or edited. The
// entries past its end read as zero rather than past the buffer.
add_repair(doc, .Bad_Resource, 0)
}
return cs, .None
}
@(private)
cs_load_separation :: proc(doc: ^Document, a: ^Array, res: ^Dict, depth: int) -> (^Colorspace, Error) {
cs := cs_new(doc, .Separation, 1, "Separation")
colorant := array_name(doc, a, 1)
names := make([]string, 1, doc.allocator)
names[0] = colorant
cs.colorant_names = names
// /None marks nothing on the page at all; /All marks every separation
// (8.6.6.4).
cs.is_none = colorant == "None"
cs.is_all = colorant == "All"
cs_load_tint(doc, cs, a, res, depth)
return cs, .None
}
@(private)
cs_load_devicen :: proc(doc: ^Document, a: ^Array, res: ^Dict, depth: int) -> (^Colorspace, Error) {
list := to_array(array_get(doc, a, 1)) or_else nil
n := array_len(list)
if n < 1 {
return nil, .Bad_Colorspace
}
// 8.6.6.5 caps a DeviceN space at 32 colorants, which is also the width of
// a Color.
n = min(n, MAX_COLOR_COMPONENTS)
cs := cs_new(doc, .Device_N, n, "DeviceN")
names := make([]string, n, doc.allocator)
none_count := 0
for i in 0 ..< n {
names[i] = array_name(doc, list, i)
if names[i] == "None" {
none_count += 1
}
}
cs.colorant_names = names
// A DeviceN marks nothing only when every one of its colorants is /None.
cs.is_none = none_count == n
cs_load_tint(doc, cs, a, res, depth)
return cs, .None
}
// cs_load_tint fills in the alternate space and tint transform shared by
// Separation and DeviceN. Both may be missing or broken, and neither failure
// is a reason to reject the space: `colorspace_to_rgb` falls back to treating
// the colorant as ink coverage, which keeps a spot colour dark instead of
// dropping the artwork that uses it.
@(private)
cs_load_tint :: proc(doc: ^Document, cs: ^Colorspace, a: ^Array, res: ^Dict, depth: int) {
// 8.6.6.4 and 8.6.6.5: the alternate space "shall be any device or
// CIE-based colour space but shall not be another special colour space
// (Pattern, Indexed, Separation, or DeviceN)". All four are refused, and
// for the same reason -- none of them can be handed the output of a tint
// transform and give a colour back. The components of a tint transform's
// output run 0..1; an Indexed component is a palette index, so following
// one collapses the whole ramp onto two entries, and a Pattern has no
// colour value at all. pdfium refuses the whole space at this point;
// dropping to the ink-coverage fallback below is gentler and keeps the
// artwork on the page.
refused := false
if alt, err := cs_load(doc, array_get_raw(a, 2), res, depth + 1); err == .None && alt != nil {
#partial switch alt.kind {
case .Pattern, .Indexed, .Separation, .Device_N:
refused = true
case:
cs.alt = alt
}
}
if tint, err := function_load(doc, array_get_raw(a, 3)); err == .None && tint != nil && tint.n_out >= 1 {
if cs.alt == nil && !refused {
// A tint transform with no alternate space still says how many
// components it produces, and a device space with that many is a
// far better guess than giving up on the colour entirely. That
// does not extend to an alternate that was named and refused: its
// outputs mean whatever that space's components mean, which is
// exactly what cannot be read as a device colour.
cs.alt = colorspace_device_n(tint.n_out)
}
if cs.alt != nil && tint.n_out == cs.alt.n {
cs.tint = tint
}
}
if cs.tint == nil || cs.alt == nil {
add_repair(doc, .Bad_Resource, 0)
}
}
@(private)
cs_load_pattern :: proc(doc: ^Document, a: ^Array, res: ^Dict, depth: int) -> (^Colorspace, Error) {
under, err := cs_load(doc, array_get_raw(a, 1), res, depth + 1)
if err != .None || under == nil || under.kind == .Pattern {
return &cs_pattern, .None
}
cs := cs_new(doc, .Pattern, under.n, "Pattern")
cs.under = under
return cs, .None
}
// ---------------------------------------------------------------------------
// Conversion to RGB
// ---------------------------------------------------------------------------
// colorspace_to_rgb converts one colour value to RGB in 0..1. It allocates
// nothing and never fails: an unconvertible colour comes back as black, since
// a page that draws the wrong colour is still a page and a page that stops
// drawing is not.
colorspace_to_rgb :: proc(cs: ^Colorspace, c: Color) -> [3]f64 {
return cs_to_rgb(cs, c, 0)
}
@(private)
cs_to_rgb :: proc(cs: ^Colorspace, c: Color, depth: int) -> [3]f64 {
if cs == nil || depth > MAX_COLORSPACE_DEPTH {
return {0, 0, 0}
}
switch cs.kind {
case .Device_Gray:
g := cs_comp(c, 0)
return {g, g, g}
case .Device_RGB:
return {cs_comp(c, 0), cs_comp(c, 1), cs_comp(c, 2)}
case .Device_CMYK:
// The naive conversion, subtracting each ink and the black from full
// intensity. It is not colorimetric and no non-colour-managed viewer
// does anything else; a real CMYK profile is the only way to do
// better and this library reads none.
cy, m, y, k := cs_comp(c, 0), cs_comp(c, 1), cs_comp(c, 2), cs_comp(c, 3)
return {
1 - min(1, cy + k),
1 - min(1, m + k),
1 - min(1, y + k),
}
case .Cal_Gray:
g := cs_cal_component(cs_comp(c, 0), cs.gamma[0])
return {g, g, g}
case .Cal_RGB:
return {
cs_cal_component(cs_comp(c, 0), cs.gamma[0]),
cs_cal_component(cs_comp(c, 1), cs.gamma[1]),
cs_cal_component(cs_comp(c, 2), cs.gamma[2]),
}
case .Lab:
return cs_lab_to_rgb(cs, c)
case .ICC_Based:
return cs_to_rgb(cs.alt, c, depth + 1)
case .Indexed:
return cs_indexed_to_rgb(cs, c, depth)
case .Separation, .Device_N:
return cs_tint_to_rgb(cs, c, depth)
case .Pattern:
// An uncoloured pattern carries the colour it is painted in, in the
// underlying space. A coloured one supplies its own, and this value is
// never asked for.
if cs.under != nil {
return cs_to_rgb(cs.under, c, depth + 1)
}
return {0, 0, 0}
}
return {0, 0, 0}
}
// cs_comp reads component i, clamped to 0..1. Used for the spaces whose
// components are all 0..1, which is every one of them but Lab and Indexed.
@(private)
cs_comp :: proc(c: Color, i: int) -> f64 {
if i < 0 || i >= c.n || i >= MAX_COLOR_COMPONENTS {
return 0
}
return clamp(clamp_finite(c.v[i], 0), 0, 1)
}
// cs_cal_component decodes one CalGray or CalRGB component.
//
// The full colorimetry -- white point, /Matrix, adaptation -- is deliberately
// not implemented: the format allows a reader to treat these as DeviceGray and
// DeviceRGB and viewers do. /Gamma is honoured, because it is one pow: the
// component is decoded to linear light and re-encoded for an sRGB output
// device. At the usual /Gamma 2.2 that round trip is within half a level of
// leaving the value alone, so the common case still matches every other
// viewer; a gamma of exactly 1 is the default and is skipped entirely.
@(private)
cs_cal_component :: proc(v: f64, gamma: f64) -> f64 {
x := clamp(clamp_finite(v, 0), 0, 1)
if gamma == 1 {
return x
}
return cs_srgb_encode(math.pow(x, gamma))
}
// cs_srgb_encode is the sRGB transfer function (IEC 61966-2-1), taking linear
// light to a display value.
@(private)
cs_srgb_encode :: proc(v: f64) -> f64 {
x := clamp(clamp_finite(v, 0), 0, 1)
if x <= 0.0031308 {
return x * 12.92
}
return 1.055 * math.pow(x, 1.0 / 2.4) - 0.055
}
// ---------------------------------------------------------------------------
// Lab
// ---------------------------------------------------------------------------
// lab_to_srgb_matrix builds XYZ-under-`wp` to linear sRGB.
//
// sRGB is defined against D65 and PDF's Lab spaces are almost always D50, so
// the two are joined by a Bradford chromatic adaptation. Without it a D50
// white -- L* 100, the commonest colour in any Lab image -- renders as a
// yellow cast rather than as white.
@(private)
lab_to_srgb_matrix :: proc(wp: [3]f64) -> [9]f64 {
// Bradford cone response and its inverse.
ma := [9]f64{
0.8951, 0.2664, -0.1614,
-0.7502, 1.7135, 0.0367,
0.0389, -0.0685, 1.0296,
}
ma_inv := [9]f64{
0.9869929, -0.1470543, 0.1599627,
0.4323053, 0.5183603, 0.0492912,
-0.0085287, 0.0400428, 0.9684867,
}
// XYZ (D65) to linear sRGB.
to_rgb := [9]f64{
3.2404542, -1.5371385, -0.4985314,
-0.9692660, 1.8760108, 0.0415560,
0.0556434, -0.2040259, 1.0572252,
}
d65 := [3]f64{0.95047, 1.0, 1.08883}
src := mat3_mul_vec(ma, wp)
dst := mat3_mul_vec(ma, d65)
scale: [9]f64
for i in 0 ..< 3 {
// A white point component of zero was rejected at load time; this is
// belt and braces, since a division by zero here would poison every
// colour the space produces.
scale[i * 3 + i] = src[i] != 0 ? dst[i] / src[i] : 1
}
adapt := mat3_mul(ma_inv, mat3_mul(scale, ma))
return mat3_mul(to_rgb, adapt)
}
@(private)
mat3_mul :: proc(a, b: [9]f64) -> (m: [9]f64) {
for r in 0 ..< 3 {
for c in 0 ..< 3 {
sum := 0.0
for k in 0 ..< 3 {
sum += a[r * 3 + k] * b[k * 3 + c]
}
m[r * 3 + c] = sum
}
}
return
}
@(private)
mat3_mul_vec :: proc(a: [9]f64, v: [3]f64) -> (o: [3]f64) {
for r in 0 ..< 3 {
o[r] = a[r * 3] * v[0] + a[r * 3 + 1] * v[1] + a[r * 3 + 2] * v[2]
}
return
}
// cs_lab_g inverts the CIE L* nonlinearity.
@(private)
cs_lab_g :: proc(x: f64) -> f64 {
// 6/29, below which the curve is linear so that its slope stays finite.
if x >= 6.0 / 29.0 {
return x * x * x
}
return (108.0 / 841.0) * (x - 4.0 / 29.0)
}
@(private)
cs_lab_to_rgb :: proc(cs: ^Colorspace, c: Color) -> [3]f64 {
l := clamp(clamp_finite(c.n > 0 ? c.v[0] : 0, 0), 0, 100)
a := clamp(clamp_finite(c.n > 1 ? c.v[1] : 0, 0), cs.range[0], cs.range[1])
b := clamp(clamp_finite(c.n > 2 ? c.v[2] : 0, 0), cs.range[2], cs.range[3])
m := (l + 16) / 116
xw := cs.white_point[0] * cs_lab_g(m + a / 500)
yw := cs.white_point[1] * cs_lab_g(m)
zw := cs.white_point[2] * cs_lab_g(m - b / 200)
out: [3]f64
for i in 0 ..< 3 {
lin := cs.mtx[i * 3] * xw + cs.mtx[i * 3 + 1] * yw + cs.mtx[i * 3 + 2] * zw
// Colours outside the sRGB gamut -- most of the Lab space is -- are
// clipped per channel, which is what every viewer without a gamut
// mapping engine does.
out[i] = cs_srgb_encode(lin)
}
return out
}
// ---------------------------------------------------------------------------
// Indexed
// ---------------------------------------------------------------------------
@(private)
cs_indexed_to_rgb :: proc(cs: ^Colorspace, c: Color, depth: int) -> [3]f64 {
base := cs.base
if base == nil {
return {0, 0, 0}
}
// An index out of range is clamped, never followed: the table is exactly
// (hival+1) entries and a file is free to name entry 300 of a 4-entry one.
idx := int(clamp(clamp_finite(math.round(c.n > 0 ? c.v[0] : 0), 0), 0, f64(cs.hival)))
comp: Color
comp.n = min(base.n, MAX_COLOR_COMPONENTS)
for j in 0 ..< comp.n {
off := idx * base.n + j
raw := off >= 0 && off < len(cs.lookup) ? f64(cs.lookup[off]) : 0
lo, hi := cs_component_range(base, j)
comp.v[j] = lo + raw * (hi - lo) / 255
}
return cs_to_rgb(base, comp, depth + 1)
}
// cs_component_range is the interval component j of a colour in this space
// runs over. Everything is 0..1 except Lab, whose L is 0..100 and whose a and
// b carry their own /Range.
@(private)
cs_component_range :: proc(cs: ^Colorspace, j: int) -> (lo, hi: f64) {
if cs != nil && cs.kind == .Lab {
switch j {
case 0: return 0, 100
case 1: return cs.range[0], cs.range[1]
case 2: return cs.range[2], cs.range[3]
}
}
return 0, 1
}
// ---------------------------------------------------------------------------
// Separation and DeviceN
// ---------------------------------------------------------------------------
@(private)
cs_tint_to_rgb :: proc(cs: ^Colorspace, c: Color, depth: int) -> [3]f64 {
if cs.is_none {
// Nothing is painted in a /None space at all. The interpreter checks
// `is_none` before drawing; this value only decides what a caller that
// does not sees, and white is the least destructive answer.
return {1, 1, 1}
}
if cs.tint != nil && cs.alt != nil {
in_: [MAX_COLOR_COMPONENTS]f64
out_: [MAX_COLOR_COMPONENTS]f64
n := min(cs.n, MAX_COLOR_COMPONENTS)
for i in 0 ..< n {
in_[i] = clamp_finite(i < c.n ? c.v[i] : 0, 0)
}
alt_n := min(cs.alt.n, MAX_COLOR_COMPONENTS)
function_eval(cs.tint, in_[:n], out_[:alt_n])
alt_color: Color
alt_color.n = alt_n
for i in 0 ..< alt_n {
alt_color.v[i] = out_[i]
}
return cs_to_rgb(cs.alt, alt_color, depth + 1)
}
// No usable tint transform. Treating the darkest colorant as ink coverage
// keeps a spot colour dark and a light tint light, which is much closer
// than either black or white and never loses the artwork.
ink := 0.0
for i in 0 ..< min(cs.n, c.n) {
ink = max(ink, clamp(clamp_finite(c.v[i], 0), 0, 1))
}
g := 1 - ink
return {g, g, g}
}
// ---------------------------------------------------------------------------
// Initial values and image decode arrays
// ---------------------------------------------------------------------------
// colorspace_default_color is the colour a space starts at when it is selected
// with `cs` or `CS` (ISO 32000-2, 8.6.8): black for the device and CIE spaces,
// the first entry for Indexed, full tint for Separation and DeviceN.
colorspace_default_color :: proc(cs: ^Colorspace) -> (c: Color) {
if cs == nil {
return color_make(0)
}
n := min(cs.n, MAX_COLOR_COMPONENTS)
switch cs.kind {
case .Device_CMYK:
// 0 0 0 1: black, not the white that four zero components would be.
c.n = 4
c.v[3] = 1
case .Separation, .Device_N:
c.n = n
for i in 0 ..< n {
c.v[i] = 1
}
case .Pattern:
// Until a pattern is selected there is nothing to paint with. An
// uncoloured pattern's components come from the underlying space.
if cs.under != nil {
return colorspace_default_color(cs.under)
}
c.n = 0
case .Device_Gray, .Device_RGB, .Cal_Gray, .Cal_RGB, .Lab, .ICC_Based, .Indexed:
c.n = n
}
return
}
// colorspace_default_decode is the /Decode array an image in this space gets
// when it does not supply one (ISO 32000-2, Table 89). `bpc` matters only for
// an Indexed space, whose default maps the raw sample straight onto the
// lookup table.
//
// The result is allocated with `allocator` and belongs to the caller.
colorspace_default_decode :: proc(cs: ^Colorspace, bpc: int, allocator := context.allocator) -> []f64 {
if cs == nil {
return nil
}
n := min(cs.n, MAX_COLOR_COMPONENTS)
if n < 1 {
return nil
}
out := make([]f64, 2 * n, allocator)
if cs.kind == .Indexed {
bits := clamp(bpc, 1, 16)
out[0] = 0
out[1] = f64(int(1) << uint(bits)) - 1
return out
}
for j in 0 ..< n {
out[2 * j], out[2 * j + 1] = cs_component_range(cs, j)
}
return out
}