jxl 1.0.0

data/lib/jxl/entropy/icc_stream.rb

@@ -0,0 +1,293 @@
+# frozen_string_literal: true
+
+module JXL
+  module Entropy
+    module ICCStream # rubocop:disable Metrics/ModuleLength
+      HEADER_SIZE = 128
+      TAGS = %w[cprt wtpt bkpt rXYZ gXYZ bXYZ kXYZ rTRC gTRC bTRC kTRC chad desc chrm dmnd dmdd lumi].freeze
+      TYPES = ["XYZ ", "desc", "text", "mluc", "para", "curv", "sf32", "gbd "].freeze
+      INITIAL_HEADER = [
+        0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 109, 110, 116, 114,
+        82, 71, 66, 32, 88, 89, 90, 32, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 97, 99, 115, 112, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 246, 214, 0, 1, 0, 0, 0, 0, 211, 45,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+      ].freeze
+
+      module_function
+
+      def read(reader, max_size: 64 * 1024 * 1024)
+        size = Bit::Field.u64(reader)
+        raise ResourceLimitError, "compressed ICC profile is too large" if size > max_size
+
+        decoder = Decoder.read(reader, 41)
+        bytes = []
+        size.times do |index|
+          previous = index.positive? ? bytes[index - 1] : 0
+          previous2 = index > 1 ? bytes[index - 2] : 0
+          value = decoder.read_uint(context(index, previous, previous2))
+          raise CorruptError, "ICC byte is out of range" unless value.between?(0, 255)
+
+          bytes << value
+        end
+        decoder.final_state!
+        unpredict(bytes, max_size:).pack("C*")
+      end
+
+      def unpredict(encoded, max_size: 64 * 1024 * 1024) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+        position = 0
+        output_size, position = varint(encoded, position)
+        command_size, position = varint(encoded, position)
+        raise ResourceLimitError, "decoded ICC profile is too large" if output_size > max_size
+        raise CorruptError, "ICC command stream is truncated" if position + command_size > encoded.length
+
+        command_position = position
+        commands_end = position + command_size
+        position = commands_end
+        output = []
+        header = initial_header(output_size)
+        HEADER_SIZE.times do |index|
+          break if output.length == output_size
+
+          predict_header!(output, header, index)
+          output << ((take(encoded, position) + header[index]) & 255)
+          position += 1
+        end
+        if output.length == output_size
+          return finish(output, output_size, position, encoded.length, command_position, commands_end)
+        end
+
+        tag_count, command_position = varint(encoded, command_position, commands_end)
+        if tag_count.positive?
+          tag_count -= 1
+          append_u32(output, tag_count)
+          previous_start = HEADER_SIZE + (tag_count * 12)
+          previous_size = 0
+          while command_position < commands_end
+            command = encoded[command_position]
+            command_position += 1
+            tag_code = command & 63
+            break if tag_code.zero?
+
+            tag, position = decode_tag(encoded, position, tag_code)
+            output.concat(tag.bytes)
+            tag_size = xyz_tag?(tag) ? 20 : previous_size
+            if command.anybits?(64)
+              tag_start, command_position = varint(encoded, command_position, commands_end)
+            else
+              tag_start = previous_start + previous_size
+            end
+            append_u32(output, tag_start)
+            tag_size, command_position = varint(encoded, command_position, commands_end) if command.anybits?(128)
+            append_u32(output, tag_size)
+            previous_start = tag_start
+            previous_size = tag_size
+            append_companion_tags(output, tag_code, tag_start, tag_size)
+            raise CorruptError, "decoded ICC profile exceeds its size" if output.length > output_size
+          end
+        end
+
+        while command_position < commands_end
+          command = encoded[command_position]
+          command_position += 1
+          case command
+          when 1, 2, 3
+            count, command_position = varint(encoded, command_position, commands_end)
+            bytes = take_bytes(encoded, position, count)
+            bytes = shuffle(bytes, command) unless command == 1
+            output.concat(bytes)
+            position += count
+          when 4
+            flags = take(encoded, command_position)
+            command_position += 1
+            width = (flags & 3) + 1
+            order = (flags & 12) >> 2
+            raise CorruptError, "invalid ICC predictor" if width == 3 || order == 3
+
+            stride = width
+            stride, command_position = varint(encoded, command_position, commands_end) if flags.anybits?(16)
+            if stride < width || output.empty? || ((output.length - 1) >> 2) < stride
+              raise CorruptError, "invalid ICC predictor stride"
+            end
+
+            count, command_position = varint(encoded, command_position, commands_end)
+            residuals = take_bytes(encoded, position, count)
+            residuals = shuffle(residuals, width) if width > 1
+            start = output.length
+            residuals.each_with_index do |residual, index|
+              output << ((linear_prediction(output, start, index, stride, width, order) + residual) & 255)
+            end
+            position += count
+          when 10
+            output.concat("XYZ \0\0\0\0".bytes)
+            output.concat(take_bytes(encoded, position, 12))
+            position += 12
+          when 16...(16 + TYPES.length)
+            output.concat(TYPES.fetch(command - 16).bytes).push(0, 0, 0, 0)
+          else
+            raise CorruptError, "unknown ICC command"
+          end
+          raise CorruptError, "decoded ICC profile exceeds its size" if output.length > output_size
+        end
+        finish(output, output_size, position, encoded.length, command_position, commands_end)
+      end
+
+      def varint(bytes, position, limit = bytes.length)
+        value = 0
+        10.times do |index|
+          byte = take(bytes, position, limit)
+          position += 1
+          raise CorruptError, "ICC varint overflows" if index == 9 && byte.anybits?(126)
+
+          value |= (byte & 127) << (7 * index)
+          return [value, position] if byte.nobits?(128)
+        end
+        raise CorruptError, "ICC varint is too long"
+      end
+      private_class_method :varint
+
+      def take(bytes, position, limit = bytes.length)
+        raise CorruptError, "ICC stream is truncated" if position >= limit
+
+        bytes[position]
+      end
+      private_class_method :take
+
+      def take_bytes(bytes, position, count)
+        raise CorruptError, "ICC stream is truncated" if count.negative? || position + count > bytes.length
+
+        bytes.slice(position, count)
+      end
+      private_class_method :take_bytes
+
+      def finish(output, output_size, position, size, command_position, commands_end) # rubocop:disable Metrics/ParameterLists
+        unless output.length == output_size && position == size && command_position == commands_end
+          raise CorruptError, "invalid ICC stream ending"
+        end
+
+        output
+      end
+      private_class_method :finish
+
+      def initial_header(size)
+        INITIAL_HEADER.dup.tap { _1[0, 4] = [size].pack("N").bytes }
+      end
+      private_class_method :initial_header
+
+      def predict_header!(output, header, position) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+        header[80, 4] = output[4, 4] if position == 8
+        if position == 41
+          header[41, 3] = "PPL".bytes if output[40] == "A".ord
+          header[41, 3] = "SFT".bytes if output[40] == "M".ord
+        elsif position == 42
+          header[42, 2] = "I ".bytes if output[40, 2] == "SG".bytes
+          header[42, 2] = "NW".bytes if output[40, 2] == "SU".bytes
+        end
+      end
+      private_class_method :predict_header!
+
+      def decode_tag(encoded, position, code)
+        return ["rTRC", position] if code == 2
+        return ["rXYZ", position] if code == 3
+        return [TAGS.fetch(code - 4), position] unless code == 1
+
+        [take_bytes(encoded, position, 4).pack("C*"), position + 4]
+      rescue IndexError
+        raise CorruptError, "unknown ICC tag"
+      end
+      private_class_method :decode_tag
+
+      def xyz_tag?(tag) = %w[rXYZ gXYZ bXYZ kXYZ wtpt bkpt lumi].include?(tag)
+      private_class_method :xyz_tag?
+
+      def append_u32(output, value)
+        raise CorruptError, "ICC value exceeds 32 bits" unless value.between?(0, 0xFFFF_FFFF)
+
+        output.concat([value].pack("N").bytes)
+      end
+      private_class_method :append_u32
+
+      def append_companion_tags(output, code, start, size)
+        if code == 2
+          %w[gTRC bTRC].each do |tag|
+            output.concat(tag.bytes)
+            append_u32(output, start)
+            append_u32(output, size)
+          end
+        elsif code == 3
+          %w[gXYZ bXYZ].each_with_index do |tag, index|
+            output.concat(tag.bytes)
+            append_u32(output, start + (size * (index + 1)))
+            append_u32(output, size)
+          end
+        end
+      end
+      private_class_method :append_companion_tags
+
+      def shuffle(data, width)
+        height = Num.ceil_div(data.length, width)
+        source = 0
+        row = 0
+        Array.new(data.length) do
+          value = data[source]
+          source += height
+          source = (row += 1) if source >= data.length
+          value
+        end
+      end
+      private_class_method :shuffle
+
+      def linear_prediction(data, start, index, stride, width, order) # rubocop:disable Metrics/AbcSize,Metrics/ParameterLists
+        position = start + index
+        values = 3.times.map do |offset|
+          base = if width == 1
+                   position - (stride * (offset + 1))
+                 else
+                   start + (index - (index % width)) - (stride * (offset + 1))
+                 end
+          data.slice(base, width).inject(0) { |value, byte| (value << 8) | byte }
+        end
+        predicted = case order
+                    when 0 then values[0]
+                    when 1 then (2 * values[0]) - values[1]
+                    when 2 then (3 * values[0]) - (3 * values[1]) + values[2]
+                    end
+        shift = width - 1 - (index % width)
+        (predicted >> (shift * 8)) & 255
+      end
+      private_class_method :linear_prediction
+
+      def context(index, previous, previous2)
+        return 0 if index <= 128
+
+        1 + byte_kind1(previous) + (byte_kind2(previous2) * 8)
+      end
+
+      def byte_kind1(byte) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+        return 0 if byte.between?("a".ord, "z".ord) || byte.between?("A".ord, "Z".ord)
+        return 1 if byte.between?("0".ord, "9".ord) || [".".ord, ",".ord].include?(byte)
+        return 2 if byte.zero?
+        return 3 if byte == 1
+        return 4 if byte < 16
+        return 6 if byte == 255
+        return 5 if byte > 240
+
+        7
+      end
+      private_class_method :byte_kind1
+
+      def byte_kind2(byte)
+        return 0 if byte.between?("a".ord, "z".ord) || byte.between?("A".ord, "Z".ord)
+        return 1 if byte.between?("0".ord, "9".ord) || [".".ord, ",".ord].include?(byte)
+        return 2 if byte < 16
+        return 3 if byte > 240
+
+        4
+      end
+      private_class_method :byte_kind2
+    end
+  end
+end

data/lib/jxl/entropy/permutation.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module JXL
+  module Entropy
+    module Permutation
+      module_function
+
+      def read(reader, size, skip: 0)
+        raise ResourceLimitError, "permutation is too large" unless size.between?(1, 65_536)
+
+        decoder = Decoder.read(reader, 8)
+        permutation = read_with_decoder(decoder, size, skip:)
+        decoder.final_state!
+        permutation
+      end
+
+      def read_with_decoder(decoder, size, skip: 0)
+        end_position = decoder.read_uint(context(size)) + skip
+        raise CorruptError, "invalid permutation size" if end_position > size
+
+        code = Array.new(size, 0)
+        previous = 0
+        skip.upto(end_position - 1) do |index|
+          code[index] = decoder.read_uint(context(previous))
+          previous = code[index]
+          raise CorruptError, "invalid Lehmer code" if code[index] >= size - index
+        end
+        decode_lehmer(code)
+      end
+
+      def context(value)
+        [value.bit_length, 7].min
+      end
+
+      def decode_lehmer(code) # rubocop:disable Metrics/AbcSize
+        size = code.length
+        log_size = Num.ceil_log2(size)
+        padded_size = 1 << log_size
+        tree = Array.new(padded_size) { |index| (index + 1) & -(index + 1) }
+        code.each_with_index.map do |rank0, index|
+          raise CorruptError, "invalid Lehmer code" if rank0 + index >= size
+
+          rank = rank0 + 1
+          bit = padded_size
+          position = 0
+          (log_size + 1).times do
+            candidate = position + bit
+            bit >>= 1
+            next unless tree[candidate - 1] < rank
+
+            position = candidate
+            rank -= tree[candidate - 1]
+          end
+          update = position + 1
+          while update <= padded_size
+            tree[update - 1] -= 1
+            update += update & -update
+          end
+          position
+        end
+      end
+    end
+  end
+end

data/lib/jxl/entropy/prefix_code.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+module JXL
+  module Entropy
+    class PrefixCode
+      MAX_BITS = 15
+      CODE_LENGTH_ORDER = [1, 2, 3, 4, 0, 5, 17, 6, 16, 7, 8, 9, 10, 11, 12, 13, 14, 15].freeze
+      CODE_LENGTH_TABLE = [[2, 0], [2, 4], [2, 3], [3, 2],
+                           [2, 0], [2, 4], [2, 3], [4, 1],
+                           [2, 0], [2, 4], [2, 3], [3, 2],
+                           [2, 0], [2, 4], [2, 3], [4, 5]].freeze
+
+      def initialize(codes, constant = nil)
+        @codes = codes
+        @constant = constant
+      end
+
+      def self.constant(symbol) = new({}, symbol)
+
+      def read(reader)
+        return @constant unless @constant.nil?
+
+        key = 0
+        1.upto(MAX_BITS) do |length|
+          key |= reader.read(1) << (length - 1)
+          symbol = @codes[length]&.[](key)
+          return symbol unless symbol.nil?
+        end
+        raise CorruptError, "invalid prefix code"
+      end
+
+      def self.read(reader, alphabet_size)
+        raise CorruptError, "invalid prefix alphabet" unless alphabet_size.between?(1, 1 << MAX_BITS)
+
+        simple_or_skip = reader.read(2)
+        return read_simple(reader, alphabet_size) if simple_or_skip == 1
+
+        lengths = read_complex_lengths(reader, alphabet_size, simple_or_skip)
+        from_code_lengths(lengths)
+      end
+
+      def self.from_code_lengths(lengths) # rubocop:disable Metrics/AbcSize
+        symbols = lengths.each_index.select { |symbol| lengths[symbol].positive? }
+        raise CorruptError, "empty prefix code" if symbols.empty?
+        return new({}, symbols.first) if symbols.one?
+
+        counts = lengths.tally
+        space = 1 << MAX_BITS
+        1.upto(MAX_BITS) { |length| space -= counts.fetch(length, 0) << (MAX_BITS - length) }
+        raise CorruptError, "incomplete prefix code" unless space.zero?
+
+        codes = Array.new(MAX_BITS + 1) { {} }
+        key = 0
+        1.upto(MAX_BITS) do |length|
+          symbols.select { |symbol| lengths[symbol] == length }.each do |symbol|
+            codes[length][key] = symbol
+            key = next_key(key, length)
+          end
+        end
+        new(codes)
+      end
+
+      def self.read_simple(reader, alphabet_size)
+        bit_count = (alphabet_size - 1).bit_length
+        count = reader.read(2) + 1
+        symbols = Array.new(count) { reader.read(bit_count) }
+        raise CorruptError, "invalid simple prefix symbol" if symbols.any? { |symbol| symbol >= alphabet_size }
+        raise CorruptError, "duplicate simple prefix symbol" unless symbols.uniq.length == symbols.length
+
+        shape = count == 4 && !reader.read(1).zero?
+        simple_codes(symbols, shape)
+      end
+      private_class_method :read_simple
+
+      def self.simple_codes(symbols, alternate_shape)
+        case symbols.length
+        when 1 then new({}, symbols[0])
+        when 2 then from_code_lengths_for(symbols.sort, [1, 1])
+        when 3 then new([{}, { 0 => symbols[0] }, { 1 => [symbols[1], symbols[2]].min,
+                                                    3 => [symbols[1], symbols[2]].max }])
+        when 4
+          alternate_shape ? simple_four_alternate(symbols) : from_code_lengths_for(symbols.sort, [2, 2, 2, 2])
+        else
+          raise InternalError, "invalid simple prefix code"
+        end
+      end
+      private_class_method :simple_codes
+
+      def self.simple_four_alternate(symbols)
+        tail = symbols.drop(2).sort
+        new([{}, { 0 => symbols[0] }, { 1 => symbols[1] }, { 3 => tail[0], 7 => tail[1] }])
+      end
+      private_class_method :simple_four_alternate
+
+      def self.from_code_lengths_for(symbols, lengths)
+        full = Array.new(symbols.max + 1, 0)
+        symbols.zip(lengths) { |symbol, length| full[symbol] = length }
+        from_code_lengths(full)
+      end
+      private_class_method :from_code_lengths_for
+
+      def self.read_complex_lengths(reader, alphabet_size, skip)
+        code_length_lengths = Array.new(18, 0)
+        space = 32
+        nonzero = 0
+        skip.upto(17) do |index|
+          break unless space.positive?
+
+          bits, value = CODE_LENGTH_TABLE.fetch(reader.peek(4))
+          reader.skip(bits)
+          code_length_lengths[CODE_LENGTH_ORDER[index]] = value
+          next if value.zero?
+
+          space -= 32 >> value
+          nonzero += 1
+        end
+        raise CorruptError, "invalid prefix code-length code" unless nonzero == 1 || space.zero?
+
+        read_symbol_lengths(reader, alphabet_size, from_code_lengths(code_length_lengths))
+      end
+      private_class_method :read_complex_lengths
+
+      def self.read_symbol_lengths(reader, alphabet_size, code)
+        lengths = Array.new(alphabet_size, 0)
+        symbol = 0
+        previous = 8
+        repeat = 0
+        repeated_length = 0
+        space = 1 << MAX_BITS
+        while symbol < alphabet_size && space.positive?
+          length = code.read(reader)
+          if length < 16
+            repeat = 0
+            lengths[symbol] = length
+            symbol += 1
+            unless length.zero?
+              previous = length
+              space -= 1 << (MAX_BITS - length)
+            end
+            next
+          end
+
+          repeated_length, repeat, symbol, space = repeat_lengths(
+            reader, lengths, symbol, length, previous, repeated_length, repeat, space
+          )
+        end
+        raise CorruptError, "incomplete prefix code lengths" unless space.zero?
+
+        lengths
+      end
+      private_class_method :read_symbol_lengths
+
+      def self.repeat_lengths(reader, lengths, symbol, code, previous, old_length, repeat, space) # rubocop:disable Metrics/ParameterLists
+        extra_bits = code - 14
+        new_length = code == 16 ? previous : 0
+        repeat = 0 if old_length != new_length
+        old_repeat = repeat
+        repeat = ((repeat - 2) << extra_bits) if repeat.positive?
+        repeat += reader.read(extra_bits) + 3
+        count = repeat - old_repeat
+        raise CorruptError, "prefix repeat exceeds alphabet" if symbol + count > lengths.length
+
+        lengths.fill(new_length, symbol, count)
+        space -= count << (MAX_BITS - new_length) unless new_length.zero?
+        [new_length, repeat, symbol + count, space]
+      end
+      private_class_method :repeat_lengths
+
+      def self.next_key(key, length)
+        step = 1 << (length - 1)
+        step >>= 1 while key.anybits?(step)
+        (key & (step - 1)) + step
+      end
+      private_class_method :next_key
+    end
+  end
+end

data/lib/jxl/errors.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module JXL
+  class Error < StandardError; end
+  class FormatError < Error; end
+  class SignatureError < FormatError; end
+  class TruncatedError < FormatError; end
+  class CorruptError < FormatError; end
+  class UnsupportedFeatureError < Error; end
+  class ResourceLimitError < Error; end
+  class InternalError < Error; end
+end

data/lib/jxl/features/noise.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+module JXL
+  module Features
+    module Noise
+      MASK64 = (1 << 64) - 1
+      GROUP_SIZE = 256
+
+      class Random
+        def initialize(a, b, c, d)
+          @s0 = Array.new(8)
+          @s1 = Array.new(8)
+          @s0[0] = splitmix(((a << 32) + b + 0x9E3779B97F4A7C15) & MASK64)
+          @s1[0] = splitmix(((c << 32) + d + 0x9E3779B97F4A7C15) & MASK64)
+          1.upto(7) do |index|
+            @s0[index] = splitmix(@s0[index - 1])
+            @s1[index] = splitmix(@s1[index - 1])
+          end
+        end
+
+        def fill
+          Array.new(8) do |index|
+            first = @s0[index]
+            second = @s1[index]
+            bits = (first + second) & MASK64
+            @s0[index] = second
+            first ^= (first << 23) & MASK64
+            @s1[index] = (first ^ second ^ (first >> 18) ^ (second >> 5)) & MASK64
+            bits
+          end
+        end
+
+        private
+
+        def splitmix(value)
+          value = ((value ^ (value >> 30)) * 0xBF58476D1CE4E5B9) & MASK64
+          value = ((value ^ (value >> 27)) * 0x94D049BB133111EB) & MASK64
+          (value ^ (value >> 31)) & MASK64
+        end
+      end
+
+      module_function
+
+      def apply(channels, lut, correlation)
+        return channels unless lut&.any? { _1.abs > 1e-3 }
+
+        width = channels[0].width
+        height = channels[0].height
+        random = Array.new(3) { Plane.new(width, height) }
+        Num.ceil_div(height, GROUP_SIZE).times do |gy|
+          Num.ceil_div(width, GROUP_SIZE).times do |gx|
+            fill_group!(random, gx * GROUP_SIZE, gy * GROUP_SIZE)
+          end
+        end
+        filtered = random.map { convolve(_1) }
+        add!(channels, filtered, lut, correlation)
+      end
+
+      def fill_group!(planes, x0, y0)
+        width = [GROUP_SIZE, planes[0].width - x0].min
+        height = [GROUP_SIZE, planes[0].height - y0].min
+        rng = Random.new(1, 0, x0, y0)
+        planes.each do |plane|
+          height.times do |y|
+            values = random_row(rng, width)
+            plane.data[((y0 + y) * plane.width) + x0, width] = values
+          end
+        end
+      end
+      private_class_method :fill_group!
+
+      def random_row(rng, width)
+        values = []
+        values.concat(random_floats(rng.fill)) while values.length + 16 < width
+        values.concat(random_floats(rng.fill))
+        values.first(width)
+      end
+      private_class_method :random_row
+
+      def random_floats(words)
+        words.pack("Q<*").unpack("L<*").map { |bits| [0x3F80_0000 | (bits >> 9)].pack("L<").unpack1("e") }
+      end
+      private_class_method :random_floats
+
+      def convolve(source)
+        output = Plane.new(source.width, source.height)
+        source.height.times do |y|
+          source.width.times do |x|
+            others = 5.times.sum do |dy|
+              5.times.sum do |dx|
+                next 0.0 if dx == 2 && dy == 2
+
+                sample(source, x + dx - 2, y + dy - 2)
+              end
+            end
+            output[x, y] = (0.16 * others) - (3.84 * source[x, y])
+          end
+        end
+        output
+      end
+      private_class_method :convolve
+
+      def add!(channels, random, lut, correlation)
+        ytox = correlation.x_ratio(0)
+        ytob = correlation.b_ratio(0)
+        channels[0].data.length.times do |index|
+          x = channels[0].data[index]
+          y = channels[1].data[index]
+          red = strength(lut, (y + x) * 0.5) * 0.22 *
+                ((random[2].data[index] * 127 / 128.0) + (random[0].data[index] / 128.0))
+          green = strength(lut, (y - x) * 0.5) * 0.22 *
+                  ((random[2].data[index] * 127 / 128.0) + (random[1].data[index] / 128.0))
+          combined = red + green
+          channels[0].data[index] += red - green + (ytox * combined)
+          channels[1].data[index] += combined
+          channels[2].data[index] += ytob * combined
+        end
+        channels
+      end
+      private_class_method :add!
+
+      def strength(lut, value)
+        scaled = [value * 6, 0.0].max
+        index = scaled >= 7 ? 6 : scaled.floor
+        fraction = scaled >= 7 ? 1.0 : scaled - index
+        Num.clamp(lut[index] + ((lut[index + 1] - lut[index]) * fraction), 0.0, 1.0)
+      end
+      private_class_method :strength
+
+      def sample(plane, x, y) = plane[mirror(x, plane.width), mirror(y, plane.height)]
+      private_class_method :sample
+
+      def mirror(value, size)
+        value %= 2 * size
+        value < size ? value : (2 * size) - value - 1
+      end
+      private_class_method :mirror
+    end
+  end
+end