// Port of jxl-color `convert.rs`: color transformation between color encodings.

///|
/// Color encoding represented by either enum values or an ICC profile.
pub struct ColorEncodingWithProfile {
  priv encoding : ColourEncoding
  priv icc_profile : Bytes
  priv is_cmyk : Bool
}

///|
/// Creates a color encoding from enum values.
pub fn ColorEncodingWithProfile::new(
  encoding : EnumColourEncoding,
) -> ColorEncodingWithProfile {
  { encoding: Enum(encoding), icc_profile: b"", is_cmyk: false, }
}

///|
/// Creates a color encoding from ICC profile.
///
/// Raises an error if it cannot parse the ICC profile.
pub fn ColorEncodingWithProfile::with_icc(
  icc_profile : Bytes,
) -> ColorEncodingWithProfile raise @bitstream.JxlError {
  let parsed : Result[EnumColourEncoding, @bitstream.JxlError] = Ok(
    parse_icc(icc_profile),
  ) catch {
    e => Err(e)
  }
  match parsed {
    Ok(encoding) => ColorEncodingWithProfile::new(encoding)
    Err(@bitstream.Color("UnsupportedIccProfile")) => {
      let raw = parse_icc_raw(icc_profile)
      {
        encoding: IccProfile(raw.color_space()),
        icc_profile,
        is_cmyk: raw.is_cmyk(),
      }
    }
    Err(e) => raise e
  }
}

///|
/// Returns the color encoding representation.
pub fn ColorEncodingWithProfile::encoding(
  self : ColorEncodingWithProfile,
) -> ColourEncoding {
  self.encoding
}

///|
/// Returns the associated ICC profile.
pub fn ColorEncodingWithProfile::icc_profile(
  self : ColorEncodingWithProfile,
) -> Bytes {
  self.icc_profile
}

///|
/// Returns whether the color encoding describes a grayscale color space.
pub fn ColorEncodingWithProfile::is_grayscale(
  self : ColorEncodingWithProfile,
) -> Bool {
  match self.encoding {
    Enum(encoding) => encoding.colour_space == Grey
    IccProfile(color_space) => color_space == Grey
  }
}

///|
/// Returns whether the color encoding represents CMYK color space.
pub fn ColorEncodingWithProfile::is_cmyk(
  self : ColorEncodingWithProfile,
) -> Bool {
  self.is_cmyk
}

///|
fn ColorEncodingWithProfile::is_equivalent(
  self : ColorEncodingWithProfile,
  other : ColorEncodingWithProfile,
) -> Bool {
  if self.encoding.want_icc() != other.encoding.want_icc() {
    return false
  }
  if self.encoding.want_icc() {
    return self.icc_profile == other.icc_profile
  }
  match (self.encoding, other.encoding) {
    (Enum(me), Enum(other)) => {
      if me.colour_space != other.colour_space {
        return false
      }
      if me.colour_space == Xyb {
        return true
      }
      if me.rendering_intent != other.rendering_intent ||
        me.white_point != other.white_point ||
        me.tf != other.tf {
        return false
      }
      me.colour_space == Grey || me.primaries == other.primaries
    }
    _ => false
  }
}

///|
pub struct ColorTransformBuilder {
  priv mut detect_peak : Bool
  priv mut srgb_icc : Bool
  priv mut from_pq : Bool
}

///|
/// Creates a new `ColorTransform` builder.
pub fn ColorTransformBuilder::new() -> ColorTransformBuilder {
  { detect_peak: false, srgb_icc: false, from_pq: false, }
}

///|
pub fn ColorTransformBuilder::default() -> ColorTransformBuilder {
  ColorTransformBuilder::new()
}

///|
pub fn ColorTransformBuilder::set_detect_peak(
  self : ColorTransformBuilder,
  value : Bool,
) -> ColorTransformBuilder {
  self.detect_peak = value
  self
}

///|
pub fn ColorTransformBuilder::set_srgb_icc(
  self : ColorTransformBuilder,
  value : Bool,
) -> ColorTransformBuilder {
  self.srgb_icc = value
  self
}

///|
pub fn ColorTransformBuilder::from_pq(
  self : ColorTransformBuilder,
  from_pq : Bool,
) -> ColorTransformBuilder {
  self.from_pq = from_pq
  self
}

///|
pub fn ColorTransformBuilder::build(
  self : ColorTransformBuilder,
  from : ColorEncodingWithProfile,
  to : ColorEncodingWithProfile,
  oim : OpsinInverseMatrix,
  tone_mapping : ToneMapping,
  cms : &ColorManagementSystem,
) -> ColorTransform raise @bitstream.JxlError {
  ColorTransform::with_builder(self, from, to, oim, tone_mapping, cms)
}

///|
/// Color transformation from a color encoding to another.
pub struct ColorTransform {
  priv begin_channels : Int32
  priv ops : Array[ColorTransformOp]
}

///|
/// Creates a new `ColorTransform` builder.
pub fn ColorTransform::builder() -> ColorTransformBuilder {
  ColorTransformBuilder::new()
}

///|
/// Prepares a color transformation.
///
/// Raises an error if it cannot prepare such color transformation.
pub fn ColorTransform::new(
  from : ColorEncodingWithProfile,
  to : ColorEncodingWithProfile,
  oim : OpsinInverseMatrix,
  tone_mapping : ToneMapping,
  cms : &ColorManagementSystem,
) -> ColorTransform raise @bitstream.JxlError {
  ColorTransform::with_builder(
    ColorTransformBuilder::default(),
    from,
    to,
    oim,
    tone_mapping,
    cms,
  )
}

///|
fn luminances_of(mat : FixedArray[Float]) -> FixedArray[Float] {
  [mat[3], mat[4], mat[5]]
}

///|
fn ColorTransform::with_builder(
  builder : ColorTransformBuilder,
  from : ColorEncodingWithProfile,
  to : ColorEncodingWithProfile,
  oim : OpsinInverseMatrix,
  tone_mapping : ToneMapping,
  cms : &ColorManagementSystem,
) -> ColorTransform raise @bitstream.JxlError {
  let detect_peak = builder.detect_peak
  let srgb_icc = builder.srgb_icc
  let from_pq = builder.from_pq
  let connecting_tf : TransferFunction = if srgb_icc { Srgb } else { Linear }
  let intensity_target = tone_mapping.intensity_target
  let min_nits = tone_mapping.min_nits
  let begin_channels = match from.encoding {
    Enum({ colour_space: Grey, .. }) => 1
    Enum(_) => 3
    IccProfile(_) => {
      let profile = from.icc_profile
      if profile.length() < 0x14 {
        3
      } else {
        let cs = profile[0x10:0x14]
        if cs == b"GRAY"[:] {
          1
        } else if cs == b"CMYK"[:] {
          4
        } else {
          3
        }
      }
    }
  }
  if from.is_equivalent(to) {
    return { begin_channels, ops: [], }
  }
  let ops : Array[ColorTransformOp] = []
  let mut current_encoding : EnumColourEncoding = match from.encoding {
    IccProfile(_) => {
      let rendering_intent = parse_icc_raw(from.icc_profile).header.rendering_intent
      match to.encoding {
        IccProfile(_) => {
          let transform = cms.prepare_transform(
            from.icc_profile,
            to.icc_profile,
            rendering_intent,
          )
          return { begin_channels, ops: [IccToIcc(transform)], }
        }
        Enum(encoding) => {
          let target_encoding = { ..encoding, tf: connecting_tf, }
          let to_icc = colour_encoding_to_icc(target_encoding)
          let transform = cms.prepare_transform(
            from.icc_profile,
            to_icc,
            rendering_intent,
          )
          ops.push(IccToIcc(transform))
          target_encoding
        }
      }
    }
    Enum({ colour_space: Xyb, rendering_intent, .. }) => {
      let inv_mat = oim.inv_mat
      let matrix : FixedArray[Float] = [
        inv_mat[0][0],
        inv_mat[0][1],
        inv_mat[0][2],
        inv_mat[1][0],
        inv_mat[1][1],
        inv_mat[1][2],
        inv_mat[2][0],
        inv_mat[2][1],
        inv_mat[2][2],
      ]
      ops.push(XybToMixedLms(opsin_bias=oim.opsin_bias, intensity_target~))
      ops.push(Matrix(matrix))
      // result: RGB; D65 illuminant, sRGB primaries, linear tf
      EnumColourEncoding::srgb_linear(rendering_intent)
    }
    Enum({ colour_space: Rgb, white_point, primaries, tf, .. } as encoding) => {
      let mat = primaries_to_xyz_mat(primaries, white_point)
      let luminances = luminances_of(mat)
      ops.push(
        TransferFunction(
          tf~,
          hdr_params={ luminances, intensity_target, min_nits, },
          inverse=true,
        ),
      )
      { ..encoding, tf: Linear, }
    }
    Enum({ colour_space: Grey, white_point, tf, .. } as encoding) => {
      // primaries don't matter for grayscale
      let mat = primaries_to_xyz_mat(Primaries::Srgb, white_point)
      let luminances = luminances_of(mat)
      ops.push(
        TransferFunction(
          tf~,
          hdr_params={ luminances, intensity_target, min_nits, },
          inverse=true,
        ),
      )
      { ..encoding, tf: Linear, }
    }
    Enum(_) => raise @bitstream.Color("UnsupportedColorEncoding")
  }
  let target_encoding = match to.encoding {
    Enum(encoding) => encoding
    IccProfile(_) => {
      let from_icc = colour_encoding_to_icc(current_encoding)
      let transform = cms.prepare_transform(
        from_icc,
        to.icc_profile,
        current_encoding.rendering_intent,
      )
      ops.push(IccToIcc(transform))
      return { begin_channels, ops, }
    }
  }
  if current_encoding.tf != Linear {
    ops.push(
      TransferFunction(
        tf=current_encoding.tf,
        hdr_params={ luminances: [0.0, 0.0, 0.0], intensity_target, min_nits, },
        inverse=true,
      ),
    )
    current_encoding = { ..current_encoding, tf: Linear, }
  }
  if current_encoding.colour_space != target_encoding.colour_space ||
    current_encoding.white_point != target_encoding.white_point ||
    (
      current_encoding.colour_space == Rgb &&
      current_encoding.primaries != target_encoding.primaries
    ) {
    if current_encoding.rendering_intent == Perceptual {
      let mat = primaries_to_xyz_mat(
        current_encoding.primaries,
        current_encoding.white_point,
      )
      ops.push(GamutMap(luminances=luminances_of(mat), saturation_factor=0.3))
    } else {
      ops.push(Clip)
    }
    match current_encoding.colour_space {
      Rgb => {
        // RGB to XYZ
        let mat = primaries_to_xyz_mat(
          current_encoding.primaries,
          current_encoding.white_point,
        )
        ops.push(Matrix(mat))
      }
      Grey => {
        // Yxy to XYZ
        let illuminant = AsIlluminant::as_illuminant(
          current_encoding.white_point,
        )
        ops.push(LumaToXyz(illuminant~))
      }
      Xyb | Unknown => abort("unreachable")
    }
    if current_encoding.rendering_intent != Absolute {
      // Chromatic adaptation: XYZ to XYZ
      let adapt = adapt_mat(
        current_encoding.white_point,
        target_encoding.white_point,
      )
      ops.push(Matrix(adapt))
    }
    match target_encoding.colour_space {
      Rgb => {
        // XYZ to RGB
        let mat = xyz_to_primaries_mat(
          target_encoding.primaries,
          target_encoding.white_point,
        )
        ops.push(Matrix(mat))
      }
      Grey =>
        // XYZ to Yxy
        ops.push(XyzToLuma)
      Xyb | Unknown => raise @bitstream.Color("UnsupportedColorEncoding")
    }
    current_encoding = {
      ..current_encoding,
      colour_space: target_encoding.colour_space,
      white_point: target_encoding.white_point,
      primaries: target_encoding.primaries,
    }
  }
  let mat = primaries_to_xyz_mat(
    current_encoding.primaries,
    current_encoding.white_point,
  )
  let luminances = luminances_of(mat)
  let mut hdr_params : HdrParams = { luminances, intensity_target, min_nits, }
  if intensity_target > 255.0 && !target_encoding.is_hdr() {
    if current_encoding.colour_space == Grey {
      ops.push(
        ToneMapLumaRec2408(
          hdr_params~,
          target_display_luminance=255.0,
          detect_peak~,
        ),
      )
    } else {
      ops.push(
        ToneMapRec2408(
          hdr_params~,
          target_display_luminance=255.0,
          detect_peak~,
        ),
      )
      if current_encoding.rendering_intent == Perceptual {
        ops.push(GamutMap(luminances~, saturation_factor=0.3))
      }
    }
  }

  // PQ to HLG: tonemap to peak 1000 nits before applying inverse OOTF.
  if from_pq && target_encoding.tf == Hlg {
    if !(hdr_params.intensity_target >= 999.0 &&
      hdr_params.intensity_target <= 1001.0) {
      if current_encoding.colour_space == Grey {
        ops.push(
          ToneMapLumaRec2408(
            hdr_params~,
            target_display_luminance=1000.0,
            detect_peak=false,
          ),
        )
      } else {
        ops.push(
          ToneMapRec2408(
            hdr_params~,
            target_display_luminance=1000.0,
            detect_peak=false,
          ),
        )
      }
      hdr_params = { ..hdr_params, intensity_target: 1000.0, }
      ops.push(HlgInverseOotf(hdr_params))
    }
    if current_encoding.colour_space != Grey &&
      current_encoding.rendering_intent == Perceptual {
      ops.push(GamutMap(luminances~, saturation_factor=0.1))
    }

    // Skip inverse OOTF in transfer funcion conversion.
    hdr_params = { ..hdr_params, intensity_target: 300.0, }
  }
  if target_encoding.tf != Linear {
    ops.push(
      TransferFunction(tf=target_encoding.tf, hdr_params~, inverse=false),
    )
  }
  let ret : ColorTransform = { begin_channels, ops, }
  ret.optimize()
}

///|
/// Prepares a color transformation from XYB color encoding.
///
/// Raises an error if it cannot prepare such color transformation.
pub fn ColorTransform::xyb_to_enum(
  xyb_rendering_intent : RenderingIntent,
  encoding : EnumColourEncoding,
  oim : OpsinInverseMatrix,
  tone_mapping : ToneMapping,
) -> ColorTransform raise @bitstream.JxlError {
  ColorTransform::new(
    ColorEncodingWithProfile::new(EnumColourEncoding::xyb(xyb_rendering_intent)),
    ColorEncodingWithProfile::new(encoding),
    oim,
    tone_mapping,
    NullCms::{ }, // XYB to enum colorspace shouldn't generate ICC op
  )
}

///|
pub fn ColorTransform::is_noop(self : ColorTransform) -> Bool {
  self.ops.is_empty()
}

///|
pub fn ColorTransform::input_channels(self : ColorTransform) -> Int32 {
  self.begin_channels
}

///|
pub fn ColorTransform::output_channels(self : ColorTransform) -> Int32 {
  let mut channels = self.begin_channels
  for op in self.ops {
    if op.outputs() is Some(x) {
      channels = x
    }
  }
  channels
}

///|
/// Performs the prepared color transformation on the samples.
///
/// Returns the number of final channels after transformation.
///
/// `channels` are planar sample data, all having the same length; samples
/// `start..start + len` (the whole buffers by default) are transformed.
///
/// Raises an error if it encountered ICC to ICC operation and the provided
/// CMS cannot handle it.
pub fn ColorTransform::run(
  self : ColorTransform,
  channels : Array[FixedArray[Float]],
  start~ : Int32 = 0,
  len~ : Int32 = (if channels.is_empty() { 0 } else { channels[0].length() }) -
    start,
) -> Int32 raise @bitstream.JxlError {
  let mut num_channels = self.begin_channels
  for op in self.ops {
    num_channels = op.run(channels, num_channels, start, len)
  }
  num_channels
}

///|
/// Performs the prepared color transformation on the samples, in chunks of
/// 65536 samples (jxl-oxide runs the chunks on a thread pool; here they run
/// sequentially). Peak detection of tone mapping operates per chunk.
///
/// Returns the number of final channels after transformation.
pub fn ColorTransform::run_with_threads(
  self : ColorTransform,
  channels : Array[FixedArray[Float]],
) -> Int32 raise @bitstream.JxlError {
  let total = channels.fold(init=-1, (acc, ch) => {
    if acc < 0 || ch.length() < acc {
      ch.length()
    } else {
      acc
    }
  })
  let mut ret = self.begin_channels
  let mut start = 0
  while start < total {
    let len = (total - start).min(65536)
    ret = self.run(channels, start~, len~)
    start += len
  }
  ret
}

///|
fn ColorTransform::optimize(self : ColorTransform) -> ColorTransform {
  let ops : Array[ColorTransformOp] = []
  let mut in_matrix_run = false
  for op in self.ops {
    match op {
      Matrix(mat) =>
        if in_matrix_run {
          guard ops.pop() is Some(Matrix(matrix)) else { abort("unreachable") }
          ops.push(Matrix(matmul3(mat, matrix)))
        } else {
          in_matrix_run = true
          ops.push(op)
        }
      _ => {
        in_matrix_run = false
        ops.push(op)
      }
    }
  }
  { begin_channels: self.begin_channels, ops, }
}

///|
priv struct HdrParams {
  luminances : FixedArray[Float]
  intensity_target : Float
  min_nits : Float
}

///|
enum ColorTransformOp {
  XybToMixedLms(opsin_bias~ : FixedArray[Float], intensity_target~ : Float)
  LumaToXyz(illuminant~ : FixedArray[Float])
  XyzToLuma
  Matrix(FixedArray[Float])
  TransferFunction(
    tf~ : TransferFunction,
    hdr_params~ : HdrParams,
    inverse~ : Bool
  )
  HlgInverseOotf(HdrParams)
  ToneMapRec2408(
    hdr_params~ : HdrParams,
    target_display_luminance~ : Float,
    detect_peak~ : Bool
  )
  ToneMapLumaRec2408(
    hdr_params~ : HdrParams,
    target_display_luminance~ : Float,
    detect_peak~ : Bool
  )
  GamutMap(luminances~ : FixedArray[Float], saturation_factor~ : Float)
  Clip
  IccToIcc(&PreparedTransform)
}

///|
fn ColorTransformOp::inputs(self : ColorTransformOp) -> Int32? {
  match self {
    XybToMixedLms(..) | Matrix(_) => Some(3)
    LumaToXyz(..) => Some(1)
    XyzToLuma => Some(3)
    TransferFunction(tf=Hlg, ..) => Some(3)
    TransferFunction(..) => None
    HlgInverseOotf(_) => Some(3)
    ToneMapRec2408(..) => Some(3)
    ToneMapLumaRec2408(..) => Some(1)
    GamutMap(..) => Some(3)
    Clip => None
    IccToIcc(transform) => Some(transform.num_input_channels())
  }
}

///|
fn ColorTransformOp::outputs(self : ColorTransformOp) -> Int32? {
  match self {
    XybToMixedLms(..) | Matrix(_) => Some(3)
    LumaToXyz(..) => Some(3)
    XyzToLuma => Some(1)
    TransferFunction(tf=Hlg, ..) => Some(3)
    TransferFunction(..) => None
    HlgInverseOotf(_) => Some(3)
    ToneMapRec2408(..) => Some(3)
    ToneMapLumaRec2408(..) => Some(1)
    GamutMap(..) => Some(3)
    Clip => None
    IccToIcc(transform) => Some(transform.num_output_channels())
  }
}

///|
fn ColorTransformOp::run(
  self : ColorTransformOp,
  channels : Array[FixedArray[Float]],
  num_input_channels : Int32,
  start : Int32,
  len : Int32,
) -> Int32 raise @bitstream.JxlError {
  let channel_count = channels.length()
  if self.inputs() is Some(inputs) {
    guard channel_count >= inputs else { abort("not enough channels") }
  }
  if self.outputs() is Some(outputs) {
    guard channel_count >= outputs else { abort("not enough channels") }
  }
  match self {
    XybToMixedLms(opsin_bias~, intensity_target~) => {
      xyb_run(
        channels[0],
        channels[1],
        channels[2],
        opsin_bias,
        intensity_target,
        start~,
        len~,
      )
      3
    }
    LumaToXyz(illuminant~) => {
      let a = channels[0]
      let b = channels[1]
      let c = channels[2]
      let x = illuminant[0]
      let y = illuminant[1]
      for i in start..<(start + len) {
        let luma_div_y = a[i] / y
        b[i] = a[i]
        a[i] = x * luma_div_y
        c[i] = (1.0 - x - y) * luma_div_y
      }
      3
    }
    XyzToLuma => {
      let x = channels[0]
      let y = channels[1]
      for i in start..<(start + len) {
        x[i] = y[i]
      }
      1
    }
    Matrix(matrix) => {
      let a = channels[0]
      let b = channels[1]
      let c = channels[2]
      for i in start..<(start + len) {
        let av = a[i]
        let bv = b[i]
        let cv = c[i]
        a[i] = matrix[0] * av + matrix[1] * bv + matrix[2] * cv
        b[i] = matrix[3] * av + matrix[4] * bv + matrix[5] * cv
        c[i] = matrix[6] * av + matrix[7] * bv + matrix[8] * cv
      }
      3
    }
    TransferFunction(tf~, hdr_params~, inverse=false) => {
      apply_transfer_function(
        channels, num_input_channels, tf, hdr_params, start, len,
      )
      num_input_channels
    }
    TransferFunction(tf~, hdr_params~, inverse=true) => {
      apply_inverse_transfer_function(
        channels, num_input_channels, tf, hdr_params, start, len,
      )
      num_input_channels
    }
    HlgInverseOotf({ luminances, intensity_target, .. }) => {
      // FIXME: allow grayscale images.
      hlg_inverse_oo(
        channels[0],
        channels[1],
        channels[2],
        luminances,
        intensity_target,
        start~,
        len~,
      )
      3
    }
    ToneMapRec2408(hdr_params~, target_display_luminance~, detect_peak~) => {
      tone_map(
        channels[0],
        channels[1],
        channels[2],
        hdr_params,
        target_display_luminance,
        detect_peak,
        start,
        len,
      )
      3
    }
    ToneMapLumaRec2408(hdr_params~, target_display_luminance~, detect_peak~) => {
      tone_map_luma(
        channels[0],
        hdr_params,
        target_display_luminance,
        detect_peak,
        start,
        len,
      )
      1
    }
    GamutMap(luminances~, saturation_factor~) => {
      gamut_map(
        channels[0],
        channels[1],
        channels[2],
        luminances,
        saturation_factor,
        start,
        len,
      )
      3
    }
    Clip => {
      for c in 0.. 1.0 { 1.0 } else { v }
        }
      }
      num_input_channels
    }
    IccToIcc(transform) => {
      transform.transform(channels, start, len)
      transform.num_output_channels()
    }
  }
}

///|
fn apply_transfer_function(
  channels : Array[FixedArray[Float]],
  num_channels : Int32,
  tf : TransferFunction,
  hdr_params : HdrParams,
  start : Int32,
  len : Int32,
) -> Unit {
  match tf {
    Gamma(g~, inverted=false) => {
      let gamma = (1.0e7 : Float) / Float::from_int(g)
      for c in 0.. {
      let gamma = Float::from_int(g) / 1.0e7
      for c in 0..
      for c in 0.. ()
    Linear => ()
    Srgb =>
      for c in 0.. {
      let intensity_target = hdr_params.intensity_target
      for c in 0.. {
      let gamma : Float = 1.0 / 2.6
      for c in 0.. {
      guard num_channels >= 3 else { abort("HLG needs three channels") }
      let r = channels[0]
      let g = channels[1]
      let b = channels[2]
      let luminances = hdr_params.luminances
      let intensity_target = hdr_params.intensity_target
      hlg_inverse_oo(r, g, b, luminances, intensity_target, start~, len~)
      linear_to_hlg(r, start~, len~)
      linear_to_hlg(g, start~, len~)
      linear_to_hlg(b, start~, len~)
    }
  }
}

///|
fn apply_inverse_transfer_function(
  channels : Array[FixedArray[Float]],
  num_channels : Int32,
  tf : TransferFunction,
  hdr_params : HdrParams,
  start : Int32,
  len : Int32,
) -> Unit {
  match tf {
    Gamma(g~, inverted=false) => {
      let gamma = Float::from_int(g) / 1.0e7
      for c in 0.. {
      let gamma = (1.0e7 : Float) / Float::from_int(g)
      for c in 0..
      for c in 0.. ()
    Linear => ()
    Srgb =>
      for c in 0.. {
      let intensity_target = hdr_params.intensity_target
      for c in 0.. {
      let gamma : Float = 2.6
      for c in 0.. {
      guard num_channels >= 3 else { abort("HLG needs three channels") }
      let r = channels[0]
      let g = channels[1]
      let b = channels[2]
      let luminances = hdr_params.luminances
      let intensity_target = hdr_params.intensity_target
      hlg_to_linear(r, start~, len~)
      hlg_to_linear(g, start~, len~)
      hlg_to_linear(b, start~, len~)
      hlg_oo(r, g, b, luminances, intensity_target, start~, len~)
    }
  }
}