867 lines
30 KiB
Odin
867 lines
30 KiB
Odin
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
|
|
}
|