jxl 1.0.0

data/lib/jxl/modular/decoder.rb

@@ -0,0 +1,371 @@
+# frozen_string_literal: true
+
+module JXL
+  module Modular
+    GroupedState = Data.define(:state, :header, :channels, :shapes, :original_shapes, :shifts,
+                               :first_group_channel, :group_dim, :metadata)
+
+    module Decoder
+      module_function
+
+      def decode(data, max_pixels: 100_000_000)
+        parsed = Codestream::Reader.new(data, max_pixels:).read_headers
+        decode_parsed(parsed)
+      end
+
+      def decode_parsed(parsed, render: false, references: [])
+        frame = parsed.frame_header
+        raise UnsupportedFeatureError, "VarDCT frame decoding" unless frame.encoding == :modular
+
+        metadata = parsed.basic_info.metadata
+        return decode_grouped(parsed, metadata, render:, references:) unless parsed.sections.one?
+
+        reader = Bit::Reader.new(parsed.sections.first)
+        patches = read_patches(reader, frame, metadata, references)
+        dequant = VarDCT::Dequant.read_dc(reader)
+        frame_width = frame.encoded_width
+        frame_height = frame.encoded_height
+        max_nodes = [1024 + (frame_width * frame_height / 4), 1 << 22].min
+        state = Stream.read_global_state(reader, max_nodes:)
+        count = colour_channels(metadata, frame) + metadata.extra_channels.length
+        shapes = Array.new(count) { [frame_width, frame_height] }
+        channels = Stream.decode(reader, shapes, state:, stream_id: 0, metadata:, max_nodes:).channels
+        convert_float!(channels, metadata.bit_depth)
+        image = Image.new(width: frame_width, height: frame_height, channels:, metadata:)
+        image = render_image(image, frame, dequant, parsed.transform_data) if render
+        Features::Patches.apply(image.channels, patches, references, metadata)
+        image
+      end
+
+      def decode_grouped(parsed, metadata, render: false, references: [])
+        frame = parsed.frame_header
+        frame_width = frame.encoded_width
+        frame_height = frame.encoded_height
+        group_dim = 128 << frame.group_size_shift
+        groups_x = Num.ceil_div(frame_width, group_dim)
+        groups_y = Num.ceil_div(frame_height, group_dim)
+        dc_groups = Num.ceil_div(Num.ceil_div(frame_width, 8), group_dim) *
+                    Num.ceil_div(Num.ceil_div(frame_height, 8), group_dim)
+
+        global_reader = Bit::Reader.new(parsed.sections.first)
+        patches = read_patches(global_reader, frame, metadata, references)
+        dequant = VarDCT::Dequant.read_dc(global_reader)
+        max_nodes = [1024 + (frame_width * frame_height / 4), 1 << 22].min
+        state = Stream.read_global_state(global_reader, max_nodes:)
+        count = colour_channels(metadata, frame) + metadata.extra_channels.length
+        shapes = Array.new(count) { [frame_width, frame_height] }
+        grouped = read_grouped_stream(global_reader, shapes, state:, metadata:, group_dim:, max_nodes:)
+
+        dc_width = Num.ceil_div(Num.ceil_div(frame_width, 8), group_dim)
+        dc_groups.times do |group|
+          decode_grouped_dc!(Bit::Reader.new(parsed.sections.fetch(1 + group)), grouped,
+                             group_index: group, groups_x: dc_width, stream_id: 1 + dc_groups + group)
+        end
+        group_start = 2 + dc_groups
+        group_count = groups_x * groups_y
+        frame.passes.count.times do |pass|
+          group_count.times do |group|
+            stream_id = 1 + (3 * dc_groups) + 17 + (group_count * pass) + group
+            section = parsed.sections.fetch(group_start + (group_count * pass) + group)
+            decode_grouped_pass!(Bit::Reader.new(section), grouped, frame.passes,
+                                 pass_index: pass, group_index: group, groups_x:, stream_id:)
+          end
+        end
+        channels = finish_grouped_stream(grouped)
+        convert_float!(channels, metadata.bit_depth)
+        image = Image.new(width: frame_width, height: frame_height, channels:, metadata:)
+        image = render_image(image, frame, dequant, parsed.transform_data) if render
+        Features::Patches.apply(image.channels, patches, references, metadata)
+        image
+      end
+      private_class_method :decode_grouped
+
+      def read_grouped_stream(reader, original_shapes, state:, metadata:, group_dim:,
+                              shifts: Array.new(original_shapes.length) { [0, 0] }, max_nodes: 1 << 20)
+        header = GroupHeader.read(reader)
+        shapes, meta_channels, shifts =
+          TransformOps.encoded_shapes_for(original_shapes.map(&:dup), header.transforms, shifts: shifts.map(&:dup))
+        tree, entropy = Stream.code(reader, header, state, shapes, max_nodes)
+        channels = shapes.map { |width, height| Plane.new(width, height) }
+        first_group_channel = shapes.each_index.find do |channel|
+          channel >= meta_channels && shapes[channel].any? { _1 > group_dim }
+        end || shapes.length
+        global_indices = (0...first_group_channel).reject { |channel| shapes[channel].include?(0) }
+        unless global_indices.empty?
+          entropy.start(distance_multiplier: global_indices.map { |channel| shapes[channel][0] }.max)
+          global_indices.each do |channel|
+            width, height = shapes[channel]
+            channels[channel] = decode_channel(entropy, tree, header.weighted, width, height, channel,
+                                               references: channels.take(channel))
+          end
+          entropy.final_state!
+        end
+        GroupedState.new(state:, header:, channels:, shapes:, original_shapes:, shifts:,
+                         first_group_channel:, group_dim:, metadata:)
+      end
+
+      def decode_grouped_dc!(reader, grouped, group_index:, groups_x:, stream_id:)
+        size = grouped.group_dim * 8
+        decode_grouped_bracket!(reader, grouped, group_index:, groups_x:, size:,
+                                                 min_shift: 3, max_shift: 1000, stream_id:)
+      end
+
+      def decode_grouped_pass!(reader, grouped, passes, pass_index:, group_index:, groups_x:, stream_id:)
+        min_shift, max_shift = pass_shift_range(passes, pass_index)
+        decode_grouped_bracket!(reader, grouped, group_index:, groups_x:, size: grouped.group_dim,
+                                                 min_shift:, max_shift:, stream_id:)
+      end
+
+      def finish_grouped_stream(grouped)
+        grouped.header.transforms.reverse_each do |transform|
+          inverse_transform!(grouped.channels, transform, grouped.header.weighted, grouped.metadata)
+        end
+        unless grouped.channels.map { [_1.width, _1.height] } == grouped.original_shapes
+          raise CorruptError, "modular transforms changed the requested stream shape"
+        end
+
+        grouped.channels
+      end
+
+      def inverse_transforms!(channels, header, metadata)
+        header.transforms.reverse_each do |transform|
+          inverse_transform!(channels, transform, header.weighted, metadata)
+        end
+        channels
+      end
+
+      def decode_channels(entropy, tree, weighted, shapes, stream_id)
+        shapes.each_with_index.with_object([]) do |((width, height), channel), channels|
+          channels << decode_channel(entropy, tree, weighted, width, height, channel, stream_id,
+                                     references: channels)
+        end
+      end
+
+      def section_shape(shape, shifts, channel, x, y, size)
+        hshift, vshift = shifts
+        target_x = x >> hshift
+        target_y = y >> vshift
+        width = [size >> hshift, shape[0] - target_x].min
+        height = [size >> vshift, shape[1] - target_y].min
+        return if width <= 0 || height <= 0
+
+        [channel, target_x, target_y, width, height]
+      end
+      private_class_method :section_shape
+
+      def pass_shift_range(passes, target)
+        minimum = 3
+        maximum = 2
+        passes.count.times do |pass|
+          passes.last_passes.each_with_index do |last, index|
+            minimum = passes.downsamples[index].bit_length - 1 if pass == last
+          end
+          minimum = 0 if pass == passes.count - 1
+          return [minimum, maximum] if pass == target
+
+          maximum = minimum - 1
+        end
+      end
+      private_class_method :pass_shift_range
+
+      def decode_grouped_bracket!(reader, grouped, group_index:, groups_x:, size:,
+                                  min_shift:, max_shift:, stream_id:)
+        x = (group_index % groups_x) * size
+        y = (group_index / groups_x) * size
+        selected = (grouped.first_group_channel...grouped.shapes.length).filter_map do |channel|
+          shift = grouped.shifts[channel].min
+          next unless shift.between?(min_shift, max_shift)
+
+          section_shape(grouped.shapes[channel], grouped.shifts[channel], channel, x, y, size)
+        end
+        decode_group_section!(reader, grouped.state, grouped.channels, selected, stream_id, grouped.metadata)
+      end
+      private_class_method :decode_grouped_bracket!
+
+      def decode_group_section!(reader, state, channels, selected, stream_id, metadata)
+        return if selected.empty?
+
+        shapes = selected.map { |(_, _, _, width, height)| [width, height] }
+        decoded = Stream.decode(reader, shapes, state:, stream_id:, metadata:).channels
+        selected.zip(decoded).each do |(channel, x, y, _, _), plane|
+          blit!(plane, channels[channel], x, y)
+        end
+      end
+      private_class_method :decode_group_section!
+
+      def decode_channel(entropy, tree, weighted_header, width, height, channel, group = 0, references: [])
+        plane = Plane.new(width, height)
+        weighted = Weighted.new(weighted_header, width) if tree.weighted?
+        references = [] unless tree.nodes.any? { !_1.leaf? && _1.property >= 16 }
+        height.times do |y|
+          previous_gradient = 0
+          width.times do |x|
+            weighted_guess = weighted&.predict(plane, x, y)
+            properties = Predictor.properties(plane, x, y,
+                                              channel:, group:, previous_gradient:,
+                                              weighted_property: weighted&.property || 0, references:)
+            previous_gradient = properties[9]
+            leaf = tree.leaf(properties)
+            begin
+              residual = Num.unpack_signed(entropy.read_uint(leaf.context))
+            rescue Error => e
+              raise e.class, "#{e.message} at channel #{channel}, pixel #{x},#{y}"
+            end
+            prediction = if leaf.predictor.zero?
+                           0
+                         elsif leaf.predictor == 6
+                           weighted_guess
+                         else
+                           Predictor.predict(leaf.predictor, plane, x, y)
+                         end
+            guess = prediction + leaf.offset
+            plane[x, y] = Num.i32((residual * leaf.multiplier) + guess)
+            weighted&.update(plane[x, y], x)
+          end
+        end
+        plane
+      end
+      private_class_method :decode_channel
+
+      def blit!(source, target, x, y)
+        source.height.times do |row|
+          target.data[((y + row) * target.width) + x, source.width] =
+            source.data[row * source.width, source.width]
+        end
+      end
+      private_class_method :blit!
+
+      def colour_channels(metadata, frame)
+        grayscale = metadata.colour_encoding.colour_space == 1
+        grayscale && frame.colour_transform == :none ? 1 : 3
+      end
+      private_class_method :colour_channels
+
+      def read_dc_quantization(reader)
+        return if Bit::Field.read_bool(reader)
+
+        3.times do
+          value = Bit::Field.f16(reader) / 128.0
+          raise CorruptError, "invalid DC quantization" unless value.positive?
+        end
+      end
+      private_class_method :read_dc_quantization
+
+      def read_patches(reader, frame, metadata, references)
+        return unless frame.flags.anybits?(2)
+
+        Features::Patches.read(reader, frame.encoded_width, frame.encoded_height,
+                               metadata.extra_channels.length, references)
+      end
+      private_class_method :read_patches
+
+      def render_image(image, frame, dequant, transform_data)
+        source = image.channels
+        colour_count = colour_channels(image.metadata, frame)
+        output = if frame.colour_transform == :xyb
+                   Array.new(3) { Plane.new(image.width, image.height) }.tap do |planes|
+                     source[0].data.length.times do |index|
+                       planes[0].data[index] = source[1].data[index] * dequant.dc[0]
+                       planes[1].data[index] = source[0].data[index] * dequant.dc[1]
+                       planes[2].data[index] = (source[2].data[index] + source[0].data[index]) * dequant.dc[2]
+                     end
+                   end
+                 else
+                   normalize_integer(source.first(colour_count), image.metadata.bit_depth)
+                 end
+        extras = source.drop(colour_count).each_with_index.map do |plane, index|
+          depth = image.metadata.extra_channels[index].bit_depth
+          normalize_integer([plane], depth).first
+        end
+        filtered = if colour_count == 1
+                     grey = if frame.loop_filter.gaborish
+                              Filter::Gaborish.convolve(output.first, frame.loop_filter.gaborish_weights.first)
+                            else
+                              output.first
+                            end
+                     Array.new(3, grey) + extras
+                   else
+                     Filter::Gaborish.apply(output + extras, frame.loop_filter)
+                   end
+        filtered = Filter::EPF.apply_modular(filtered, frame.loop_filter)
+        filtered = Features::Upsampling.apply(filtered, frame, transform_data) unless frame.type == 1
+        filtered = [filtered.first] + filtered.drop(3) if colour_count == 1
+        dimensions = if frame.type == 1
+                       { width: image.width, height: image.height }
+                     else
+                       { width: frame.width, height: frame.height }
+                     end
+        image.with(**dimensions, channels: filtered)
+      end
+      private_class_method :render_image
+
+      def normalize_integer(planes, depth)
+        return planes if depth.floating_point
+
+        scale = 1.0 / ((1 << depth.bits_per_sample) - 1)
+        planes.map do |plane|
+          Plane.new(plane.width, plane.height).tap { _1.data.replace(plane.data.map { |value| value * scale }) }
+        end
+      end
+      private_class_method :normalize_integer
+
+      def inverse_transform!(channels, transform, weighted, metadata)
+        if transform.id.zero?
+          inverse_rct!(channels, transform)
+        else
+          TransformOps.inverse!(channels, transform, weighted, metadata.bit_depth.bits_per_sample)
+        end
+      end
+      private_class_method :inverse_transform!
+
+      def convert_float!(channels, bit_depth)
+        return unless bit_depth.floating_point
+        unless bit_depth.bits_per_sample == 32 && bit_depth.exponent_bits == 8
+          raise UnsupportedFeatureError, "non-binary32 floating point samples"
+        end
+
+        channels.each do |plane|
+          plane.data.map! { |value| [Num.u32(value)].pack("L<").unpack1("e") }
+        end
+      end
+      private_class_method :convert_float!
+
+      def inverse_rct!(channels, transform)
+        first = transform.begin_channel
+        raise CorruptError, "RCT channel range" if first + 2 >= channels.length
+
+        type = transform.rct_type % 7
+        permutation = transform.rct_type / 7
+        return permute!(channels, first, permutation) if type.zero?
+
+        targets = [permutation % 3, (permutation + 1 + (permutation / 3)) % 3,
+                   (permutation + 2 - (permutation / 3)) % 3]
+        source = channels.slice(first, 3)
+        source.first.data.length.times do |index|
+          a, b, c = source.map { |plane| plane.data[index] }
+          if type == 6
+            tmp = Num.i32(a - (c >> 1))
+            blue = Num.i32(tmp - (b >> 1))
+            values = [Num.i32(blue + b), Num.i32(tmp + c), blue]
+          else
+            c = Num.i32(c + a) if type.odd?
+            second = type >> 1
+            b = Num.i32(b + a) if second == 1
+            b = Num.i32(b + (Num.i32(a + c) >> 1)) if second == 2
+            values = [a, b, c]
+          end
+          targets.each_with_index { |target, i| channels[first + target].data[index] = values[i] }
+        end
+      end
+      private_class_method :inverse_rct!
+
+      def permute!(channels, first, permutation)
+        source = channels.slice(first, 3)
+        targets = [permutation % 3, (permutation + 1 + (permutation / 3)) % 3,
+                   (permutation + 2 - (permutation / 3)) % 3]
+        targets.each_with_index { |target, index| channels[first + target] = source[index] }
+      end
+      private_class_method :permute!
+    end
+  end
+end

data/lib/jxl/modular/group_header.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module JXL
+  module Modular
+    WeightedHeader = Data.define(:p, :weights)
+    Squeeze = Data.define(:horizontal, :in_place, :begin_channel, :num_channels)
+    Transform = Data.define(:id, :begin_channel, :rct_type, :num_channels, :num_colors, :num_deltas,
+                            :predictor, :squeezes)
+    GroupHeader = Data.define(:use_global_tree, :weighted, :transforms) do
+      def self.read(reader)
+        use_global_tree = Bit::Field.read_bool(reader)
+        weighted = read_weighted(reader)
+        count = Bit::Field.u32(reader, Bit::Field.val(0), Bit::Field.val(1),
+                               Bit::Field.bits_offset(4, 2), Bit::Field.bits_offset(8, 18))
+        raise ResourceLimitError, "too many modular transforms" if count > 256
+
+        transforms = Array.new(count) { read_transform(reader) }
+        new(use_global_tree:, weighted:, transforms:)
+      end
+
+      def self.read_weighted(reader)
+        return WeightedHeader.new(p: [16, 10, 7, 7, 7, 0, 0], weights: [13, 12, 12, 12]) if Bit::Field.read_bool(reader)
+
+        WeightedHeader.new(p: Array.new(7) { reader.read(5) }, weights: Array.new(4) { reader.read(4) })
+      end
+      private_class_method :read_weighted
+
+      def self.read_transform(reader)
+        id = Bit::Field.u32(reader, Bit::Field.val(0), Bit::Field.val(1), Bit::Field.val(2), Bit::Field.val(3))
+        raise CorruptError, "invalid modular transform" if id == 3
+
+        return read_squeeze(reader, id) if id == 2
+
+        begin_channel = read_channel(reader)
+        return read_palette(reader, id, begin_channel) if id == 1
+
+        rct_type = Bit::Field.u32(reader, Bit::Field.val(6), Bit::Field.bits(2),
+                                  Bit::Field.bits_offset(4, 2), Bit::Field.bits_offset(6, 10))
+        raise CorruptError, "invalid RCT transform" if rct_type >= 42
+
+        Transform.new(id:, begin_channel:, rct_type:, num_channels: nil, num_colors: nil, num_deltas: nil,
+                      predictor: nil, squeezes: [])
+      end
+      private_class_method :read_transform
+
+      def self.read_palette(reader, id, begin_channel)
+        num_channels = Bit::Field.u32(reader, Bit::Field.val(1), Bit::Field.val(3), Bit::Field.val(4),
+                                      Bit::Field.bits_offset(13, 1))
+        num_colors = Bit::Field.u32(reader, Bit::Field.bits_offset(8, 0), Bit::Field.bits_offset(10, 256),
+                                    Bit::Field.bits_offset(12, 1280), Bit::Field.bits_offset(16, 5376))
+        num_deltas = Bit::Field.u32(reader, Bit::Field.val(0), Bit::Field.bits_offset(8, 1),
+                                    Bit::Field.bits_offset(10, 257), Bit::Field.bits_offset(16, 1281))
+        predictor = reader.read(4)
+        raise CorruptError, "invalid palette predictor" if predictor >= 14
+
+        Transform.new(id:, begin_channel:, rct_type: nil, num_channels:, num_colors:, num_deltas:,
+                      predictor:, squeezes: [])
+      end
+      private_class_method :read_palette
+
+      def self.read_squeeze(reader, id)
+        count = Bit::Field.u32(reader, Bit::Field.val(0), Bit::Field.bits_offset(4, 1),
+                               Bit::Field.bits_offset(6, 9), Bit::Field.bits_offset(8, 41))
+        squeezes = Array.new(count) do
+          Squeeze.new(horizontal: Bit::Field.read_bool(reader), in_place: Bit::Field.read_bool(reader),
+                      begin_channel: read_channel(reader),
+                      num_channels: Bit::Field.u32(reader, Bit::Field.val(1), Bit::Field.val(2),
+                                                   Bit::Field.val(3), Bit::Field.bits_offset(4, 4)))
+        end
+        Transform.new(id:, begin_channel: nil, rct_type: nil, num_channels: nil, num_colors: nil,
+                      num_deltas: nil, predictor: nil, squeezes:)
+      end
+      private_class_method :read_squeeze
+
+      def self.read_channel(reader)
+        Bit::Field.u32(reader, Bit::Field.bits(3), Bit::Field.bits_offset(6, 8),
+                       Bit::Field.bits_offset(10, 72), Bit::Field.bits_offset(13, 1096))
+      end
+      private_class_method :read_channel
+    end
+  end
+end

data/lib/jxl/modular/ma_tree.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module JXL
+  module Modular
+    MANode = Data.define(:property, :split_value, :left, :right, :predictor, :offset, :multiplier, :context) do
+      def leaf? = property == -1
+    end
+
+    class MATree
+      attr_reader :nodes, :leaf_count
+
+      def initialize(nodes, leaf_count)
+        @nodes = nodes
+        @leaf_count = leaf_count
+      end
+
+      def self.read(reader, max_nodes: 1 << 20)
+        decoder = Entropy::Decoder.read(reader, 6)
+        nodes = []
+        leaves = 0
+        pending = 1
+        while pending.positive?
+          raise ResourceLimitError, "MA tree is too large" if nodes.length >= max_nodes
+
+          pending -= 1
+          property = decoder.read_uint(1) - 1
+          raise CorruptError, "invalid MA tree property" unless property.between?(-1, 255)
+
+          if property == -1
+            nodes << read_leaf(decoder, leaves)
+            leaves += 1
+          else
+            split = Num.unpack_signed(decoder.read_uint(0))
+            left = nodes.length + pending + 1
+            nodes << MANode.new(property:, split_value: split, left:, right: left + 1,
+                                predictor: nil, offset: nil, multiplier: nil, context: nil)
+            pending += 2
+          end
+        end
+        decoder.final_state!
+        validate!(nodes)
+        new(nodes, leaves)
+      end
+
+      def leaf(properties)
+        index = 0
+        loop do
+          node = nodes.fetch(index)
+          return node if node.leaf?
+
+          index = (properties[node.property] || 0) > node.split_value ? node.left : node.right
+        end
+      end
+
+      def inspect_tree
+        nodes.each_with_index.map do |node, index|
+          if node.leaf?
+            "#{index}: leaf ctx=#{node.context} pred=#{node.predictor} offset=#{node.offset} mul=#{node.multiplier}"
+          else
+            "#{index}: p#{node.property}>#{node.split_value} ? #{node.left} : #{node.right}"
+          end
+        end.join("\n")
+      end
+
+      def weighted? = nodes.any? { _1.property == 15 || _1.predictor == 6 }
+
+      def self.read_leaf(decoder, context)
+        predictor = decoder.read_uint(2)
+        raise CorruptError, "invalid modular predictor" unless predictor.between?(0, 13)
+
+        offset = Num.unpack_signed(decoder.read_uint(3))
+        multiplier_log = decoder.read_uint(4)
+        raise CorruptError, "invalid modular multiplier" if multiplier_log >= 31
+
+        multiplier_bits = decoder.read_uint(5)
+        raise CorruptError, "invalid modular multiplier" if multiplier_bits >= (1 << (31 - multiplier_log)) - 1
+
+        MANode.new(property: -1, split_value: nil, left: nil, right: nil, predictor:, offset:,
+                   multiplier: (multiplier_bits + 1) << multiplier_log, context:)
+      end
+      private_class_method :read_leaf
+
+      def self.validate!(nodes)
+        nodes.each do |node|
+          next if node.leaf?
+
+          unless node.left.between?(0, nodes.length - 1) && node.right.between?(0, nodes.length - 1)
+            raise CorruptError, "invalid MA tree child"
+          end
+        end
+      end
+      private_class_method :validate!
+    end
+  end
+end

data/lib/jxl/modular/predictor.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module JXL
+  module Modular
+    module Predictor
+      module_function
+
+      def properties(plane, x, y, channel:, group: 0, previous_gradient: 0, weighted_property: 0, references: [])
+        data = plane.data
+        width = plane.width
+        index = (y * width) + x
+        left = if x.positive?
+                 data[index - 1]
+               elsif y.positive?
+                 data[index - width]
+               else
+                 0
+               end
+        top = y.positive? ? data[index - width] : left
+        topleft = x.positive? && y.positive? ? data[index - width - 1] : left
+        topright = y.positive? && x + 1 < width ? data[index - width + 1] : top
+        leftleft = x > 1 ? data[index - 2] : left
+        toptop = y > 1 ? data[index - (2 * width)] : top
+        values = [channel, group, y, x, top.abs, left.abs, top, left,
+                  left - previous_gradient, left + top - topleft,
+                  left - topleft, topleft - top, top - topright,
+                  top - toptop, left - leftleft, weighted_property]
+        references.reverse_each do |reference|
+          next unless reference.width == plane.width && reference.height == plane.height
+
+          value = reference[x, y]
+          ref_left = x.positive? ? reference[x - 1, y] : 0
+          ref_top = y.positive? ? reference[x, y - 1] : ref_left
+          ref_topleft = x.positive? && y.positive? ? reference[x - 1, y - 1] : ref_left
+          residual = value - gradient(ref_left, ref_top, ref_topleft)
+          values.push(value.abs, value, residual.abs, residual)
+        end
+        values.map { Num.i32(_1) }
+      end
+
+      def predict(kind, plane, x, y)
+        data = plane.data
+        width = plane.width
+        index = (y * width) + x
+        left = if x.positive?
+                 data[index - 1]
+               elsif y.positive?
+                 data[index - width]
+               else
+                 0
+               end
+        top = y.positive? ? data[index - width] : left
+        topleft = x.positive? && y.positive? ? data[index - width - 1] : left
+        topright = y.positive? && x + 1 < width ? data[index - width + 1] : top
+        case kind
+        when 0 then 0
+        when 1 then left
+        when 2 then top
+        when 3 then Num.cdiv(left + top, 2)
+        when 4 then select(left, top, topleft)
+        when 5 then gradient(left, top, topleft)
+        when 7 then topright
+        when 8 then topleft
+        when 9 then x > 1 ? data[index - 2] : left
+        when 10 then Num.cdiv(left + topleft, 2)
+        when 11 then Num.cdiv(topleft + top, 2)
+        when 12 then Num.cdiv(top + topright, 2)
+        when 13
+          toptop = y > 1 ? data[index - (2 * width)] : top
+          leftleft = x > 1 ? data[index - 2] : left
+          toprightright = y.positive? && x + 2 < width ? data[index - width + 2] : topright
+          Num.cdiv((6 * top) - (2 * toptop) + (7 * left) + leftleft + toprightright + (3 * topright) + 8, 16)
+        else
+          raise UnsupportedFeatureError, "weighted modular predictor"
+        end
+      end
+
+      def gradient(left, top, topleft) = (left + top - topleft).clamp([left, top].min, [left, top].max)
+
+      def select(left, top, topleft)
+        predicted = left + top - topleft
+        (predicted - left).abs < (predicted - top).abs ? left : top
+      end
+
+      def neighbors(plane, x, y)
+        left =
+          if x.positive?
+            plane[x - 1, y]
+          elsif y.positive?
+            plane[x, y - 1]
+          else
+            0
+          end
+        top = y.positive? ? plane[x, y - 1] : left
+        topright = y.positive? && x + 1 < plane.width ? plane[x + 1, y - 1] : top
+        {
+          left:, top:,
+          topleft: x.positive? && y.positive? ? plane[x - 1, y - 1] : left,
+          topright:,
+          leftleft: x > 1 ? plane[x - 2, y] : left,
+          toptop: y > 1 ? plane[x, y - 2] : top,
+          toprightright: y.positive? && x + 2 < plane.width ? plane[x + 2, y - 1] : topright
+        }
+      end
+    end
+  end
+end