jxl 1.0.0

data/lib/jxl/features/patches.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+module JXL
+  module Features
+    PatchReference = Data.define(:frame, :x, :y, :width, :height)
+    PatchBlend = Data.define(:mode, :alpha_channel, :clamp)
+    Patch = Data.define(:reference, :x, :y, :blends)
+
+    module Patches
+      module_function
+
+      def read(reader, width, height, extra_channels, references)
+        decoder = Entropy::Decoder.read(reader, 10, distance_multiplier: 0)
+        count = decoder.read_uint(0)
+        limit = 1024 + (width * height / 4)
+        raise ResourceLimitError, "too many patch references" if count > limit
+
+        ref_positions = []
+        patches = []
+        count.times do
+          ref = decoder.read_uint(1)
+          source = references[ref]
+          raise CorruptError, "invalid patch reference" unless source
+
+          x = decoder.read_uint(3)
+          y = decoder.read_uint(3)
+          patch_width = decoder.read_uint(2) + 1
+          patch_height = decoder.read_uint(2) + 1
+          if x + patch_width > source.width || y + patch_height > source.height
+            raise CorruptError, "patch exceeds reference frame"
+          end
+
+          reference = PatchReference.new(frame: ref, x:, y:, width: patch_width, height: patch_height)
+          ref_positions << reference
+          read_positions(decoder, patches, reference, width, height, extra_channels, limit)
+        end
+        decoder.final_state!
+        patches.freeze
+      end
+
+      def read_positions(decoder, patches, reference, width, height, extra_channels, limit)
+        count = decoder.read_uint(7) + 1
+        raise ResourceLimitError, "too many patch positions" if patches.length + count > limit
+
+        previous_x = previous_y = 0
+        count.times do |index|
+          x = index.zero? ? decoder.read_uint(4) : previous_x + Num.unpack_signed(decoder.read_uint(6))
+          y = index.zero? ? decoder.read_uint(4) : previous_y + Num.unpack_signed(decoder.read_uint(6))
+          if x.negative? || y.negative? || x + reference.width > width || y + reference.height > height
+            raise CorruptError, "patch exceeds target frame"
+          end
+
+          blends = Array.new(extra_channels + 1) { read_blend(decoder, extra_channels) }
+          patches << Patch.new(reference:, x:, y:, blends:)
+          previous_x = x
+          previous_y = y
+        end
+      end
+      private_class_method :read_positions
+
+      def read_blend(decoder, extra_channels)
+        mode = decoder.read_uint(5)
+        raise CorruptError, "invalid patch blend mode" unless mode.between?(0, 7)
+
+        uses_alpha = mode.between?(4, 7)
+        alpha = uses_alpha && extra_channels > 1 ? decoder.read_uint(8) : 0
+        raise CorruptError, "invalid patch alpha channel" if alpha >= extra_channels && uses_alpha
+
+        clamp = (uses_alpha || mode == 3) && !decoder.read_uint(9).zero?
+        PatchBlend.new(mode:, alpha_channel: alpha, clamp:)
+      end
+      private_class_method :read_blend
+
+      def apply(channels, patches, references, metadata)
+        return channels if patches.nil? || patches.empty?
+
+        patches.each do |patch|
+          source = references.fetch(patch.reference.frame).channels
+          patch.reference.height.times do |dy|
+            patch.reference.width.times do |dx|
+              target_index = ((patch.y + dy) * channels[0].width) + patch.x + dx
+              source_index = ((patch.reference.y + dy) * source[0].width) + patch.reference.x + dx
+              blend_pixel!(channels, source, target_index, source_index, patch.blends, metadata)
+            end
+          end
+        end
+        channels
+      end
+
+      def blend_pixel!(background, foreground, target, source, blends, metadata)
+        old = background.map { _1.data[target] }
+        new = foreground.map { _1.data[source] }
+        colour_channels = background.length - metadata.extra_channels.length
+        metadata.extra_channels.each_index do |index|
+          channel = colour_channels + index
+          background[channel].data[target] = blend_value(old[channel], new[channel], blends[1 + index],
+                                                         old, new, metadata, colour_channels:, channel:)
+        end
+        colour_channels.times do |channel|
+          background[channel].data[target] = blend_value(old[channel], new[channel], blends[0], old, new, metadata,
+                                                         colour_channels:, channel:)
+        end
+      end
+      private_class_method :blend_pixel!
+
+      def blend_value(old, new, info, background, foreground, metadata, colour_channels: 3, channel: nil)
+        alpha_index = colour_channels + info.alpha_channel
+        alpha = foreground[alpha_index] || 1.0
+        case info.mode
+        when 0 then old
+        when 1 then new
+        when 2 then old + new
+        when 3 then old * (info.clamp ? Num.clamp(new, 0.0, 1.0) : new)
+        when 4 then alpha_blend(old, background[alpha_index], new, alpha, metadata, info,
+                                alpha: channel == alpha_index)
+        when 5 then alpha_blend(new, alpha, old, background[alpha_index], metadata, info,
+                                alpha: channel == alpha_index)
+        when 6 then channel == alpha_index ? old : old + (blend_alpha(alpha, info) * new)
+        when 7
+          channel == alpha_index ? new : new + (blend_alpha(background[alpha_index] || 1.0, info) * old)
+        end
+      end
+
+      def blend(...) = blend_value(...)
+      private_class_method :blend
+
+      def blend_alpha(value, info) = info.clamp ? Num.clamp(value, 0.0, 1.0) : value
+      private_class_method :blend_alpha
+
+      def alpha_blend(bottom, bottom_alpha, top, top_alpha, metadata, info, alpha: false)
+        bottom_alpha ||= 1.0
+        top_alpha = blend_alpha(top_alpha, info)
+        output_alpha = bottom_alpha + (top_alpha * (1.0 - bottom_alpha))
+        return output_alpha if alpha
+        return 0.0 if output_alpha.zero?
+
+        associated = metadata.extra_channels[info.alpha_channel]&.alpha_associated
+        if associated
+          ((1.0 - top_alpha) * bottom) + top
+        else
+          (((1.0 - top_alpha) * bottom * bottom_alpha) + (top_alpha * top)) / output_alpha
+        end
+      end
+      private_class_method :alpha_blend
+    end
+  end
+end

data/lib/jxl/features/splines.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+module JXL
+  module Features
+    QuantizedSpline = Data.define(:deltas, :colour_dct, :sigma_dct)
+    SplineSet = Data.define(:quantization_adjustment, :starting_points, :splines)
+
+    module Splines # rubocop:disable Metrics/ModuleLength
+      CHANNEL_WEIGHTS = [0.0042, 0.075, 0.07, 0.3333].freeze
+      SQRT_HALF = Math.sqrt(0.5)
+      SQRT_TWO = Math.sqrt(2.0)
+
+      module_function
+
+      def read(reader, width, height)
+        decoder = Entropy::Decoder.read(reader, 6)
+        count = decoder.read_uint(2) + 1
+        limit = [1 << 20, width * height / 2].min
+        raise ResourceLimitError, "too many splines" if count > limit
+
+        starting_points = []
+        last_x = last_y = 0
+        count.times do |index|
+          dx = decoder.read_uint(1)
+          dy = decoder.read_uint(1)
+          x = index.zero? ? dx : last_x + Num.unpack_signed(dx)
+          y = index.zero? ? dy : last_y + Num.unpack_signed(dy)
+          validate_position!(x, y)
+          starting_points << [x.to_f, y.to_f]
+          last_x = x
+          last_y = y
+        end
+        adjustment = Num.unpack_signed(decoder.read_uint(0))
+        total_points = count
+        splines = Array.new(count) do
+          points = decoder.read_uint(3)
+          total_points += points
+          raise ResourceLimitError, "too many spline control points" if total_points > limit
+
+          deltas = Array.new(points) do
+            [Num.unpack_signed(decoder.read_uint(4)),
+             Num.unpack_signed(decoder.read_uint(4))]
+          end
+          colour = Array.new(3) { Array.new(32) { Num.unpack_signed(decoder.read_uint(5)) } }
+          sigma = Array.new(32) { Num.unpack_signed(decoder.read_uint(5)) }
+          QuantizedSpline.new(deltas:, colour_dct: colour, sigma_dct: sigma)
+        end
+        decoder.final_state!
+        SplineSet.new(quantization_adjustment: adjustment, starting_points:, splines:)
+      end
+
+      def apply(channels, set, correlation)
+        return channels unless set
+
+        set.splines.each_with_index do |quantized, index|
+          spline = dequantize(quantized, set.starting_points[index], set.quantization_adjustment, correlation)
+          draw!(channels, spline)
+        end
+        channels
+      end
+
+      def dequantize(quantized, start, adjustment, correlation)
+        inv_quant = adjustment >= 0 ? 1.0 / (1.0 + (0.125 * adjustment)) : 1.0 - (0.125 * adjustment)
+        points = [start]
+        delta_x = delta_y = 0
+        x, y = start.map(&:round)
+        quantized.deltas.each do |ddx, ddy|
+          delta_x += ddx
+          delta_y += ddy
+          x += delta_x
+          y += delta_y
+          validate_position!(x, y)
+          points << [x.to_f, y.to_f]
+        end
+        colour = quantized.colour_dct.each_with_index.map do |coefficients, channel|
+          coefficients.each_with_index.map do |value, index|
+            value * (index.zero? ? SQRT_HALF : 1.0) * CHANNEL_WEIGHTS[channel] * inv_quant
+          end
+        end
+        32.times do |index|
+          colour[0][index] += correlation.x_ratio(0) * colour[1][index]
+          colour[2][index] += correlation.b_ratio(0) * colour[1][index]
+        end
+        sigma = quantized.sigma_dct.each_with_index.map do |value, index|
+          value * (index.zero? ? SQRT_HALF : 1.0) * CHANNEL_WEIGHTS[3] * inv_quant
+        end
+        [points, colour, sigma]
+      end
+      private_class_method :dequantize
+
+      def draw!(channels, spline)
+        points, colour_dct, sigma_dct = spline
+        curve = catmull_rom(points)
+        samples = equally_spaced(curve)
+        arc_length = ((samples.length - 2) * 1.0) + samples.last[1]
+        return unless arc_length.positive?
+
+        samples.each_with_index do |(point, intensity), index|
+          progress = [1.0, index / arc_length].min
+          colour = colour_dct.map { continuous_idct(_1, 31 * progress) }
+          sigma = continuous_idct(sigma_dct, 31 * progress)
+          draw_sample!(channels, point, intensity, colour, sigma)
+        end
+      end
+      private_class_method :draw!
+
+      def catmull_rom(control_points)
+        return control_points if control_points.one?
+
+        points = control_points.dup
+        points.unshift(add(points[0], subtract(points[0], points[1])))
+        points << add(points[-1], subtract(points[-1], points[-2]))
+        result = []
+        (points.length - 3).times do |start|
+          p = points.slice(start, 4)
+          result << p[1]
+          distances = 3.times.map { |index| Math.sqrt(Math.hypot(*subtract(p[index + 1], p[index]))) }
+          raise CorruptError, "identical spline control points" if distances.any?(&:zero?)
+
+          times = [0.0]
+          distances.each { times << (times.last + _1) }
+          1.upto(15) do |step|
+            time = distances[0] + (step.fdiv(16) * distances[1])
+            a = 3.times.map do |index|
+              add(p[index], scale(subtract(p[index + 1], p[index]), (time - times[index]) / distances[index]))
+            end
+            b = 2.times.map do |index|
+              add(a[index], scale(subtract(a[index + 1], a[index]),
+                                  (time - times[index]) / (distances[index] + distances[index + 1])))
+            end
+            result << add(b[0], scale(subtract(b[1], b[0]), (time - times[1]) / distances[1]))
+          end
+        end
+        result << points[-2]
+      end
+      private_class_method :catmull_rom
+
+      def equally_spaced(points)
+        output = [[points.first, 1.0]]
+        current = points.first
+        next_index = 0
+        loop do
+          previous = current
+          length = 0.0
+          loop do
+            if next_index == points.length
+              output << [previous, length]
+              return output
+            end
+            target = points[next_index]
+            distance = Math.hypot(*subtract(target, previous))
+            if length + distance >= 1.0
+              current = add(previous, scale(subtract(target, previous), (1.0 - length) / distance))
+              output << [current, 1.0]
+              break
+            end
+            length += distance
+            previous = target
+            next_index += 1
+          end
+        end
+      end
+      private_class_method :equally_spaced
+
+      def continuous_idct(coefficients, time)
+        coefficients.each_with_index.sum do |value, index|
+          SQRT_TWO * value * Math.cos((Math::PI / 32) * index * (time + 0.5))
+        end
+      end
+      private_class_method :continuous_idct
+
+      def draw_sample!(channels, point, intensity, colour, sigma)
+        return unless sigma.finite? && !sigma.zero? && intensity.finite?
+
+        max_colour = [0.01, *colour.map { (_1 * intensity).abs }].max
+        distance = Math.sqrt(-2.0 * sigma * sigma * ((Math.log(0.1) * 5) - Math.log(max_colour)))
+        return unless distance.finite?
+
+        x0 = [0, (point[0] - distance).round].max
+        x1 = [channels[0].width - 1, (point[0] + distance).round].min
+        y0 = [0, (point[1] - distance).round].max
+        y1 = [channels[0].height - 1, (point[1] + distance).round].min
+        y0.upto(y1) do |y|
+          x0.upto(x1) do |x|
+            radius = Math.hypot(x - point[0], y - point[1])
+            factor = Math.erf(((radius * 0.5) + 0.353553391) / sigma) -
+                     Math.erf(((radius * 0.5) - 0.353553391) / sigma)
+            local = 0.25 * sigma * intensity * factor * factor
+            3.times { |channel| channels[channel][x, y] += colour[channel] * local }
+          end
+        end
+      end
+      private_class_method :draw_sample!
+
+      def validate_position!(x, y)
+        raise CorruptError, "spline coordinate is out of bounds" unless x.abs < (1 << 23) && y.abs < (1 << 23)
+      end
+      private_class_method :validate_position!
+
+      def add(a, b) = [a[0] + b[0], a[1] + b[1]]
+      def subtract(a, b) = [a[0] - b[0], a[1] - b[1]]
+      def scale(point, value) = [point[0] * value, point[1] * value]
+      private_class_method :add, :subtract, :scale
+    end
+  end
+end

data/lib/jxl/features/spot_colour.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module JXL
+  module Features
+    module SpotColour
+      module_function
+
+      def apply(image)
+        spots = image.metadata.extra_channels.each_index.select { image.metadata.extra_channels[_1].type == 2 }
+        return image if spots.empty?
+
+        colour = image.channels.first(image.num_color_channels).map do |source|
+          Plane.new(source.width, source.height).tap { _1.data.replace(source.data) }
+        end
+        spots.each do |extra_index|
+          spot = image.metadata.extra_channels[extra_index].spot_colour
+          samples = image.extra_channels[extra_index]
+          colour.each_with_index do |plane, channel|
+            plane.data.each_index do |pixel|
+              mix = spot[3] * samples.data[pixel]
+              plane.data[pixel] = (mix * spot[channel]) + ((1.0 - mix) * plane.data[pixel])
+            end
+          end
+        end
+        image.with(channels: colour + image.extra_channels)
+      end
+    end
+  end
+end

data/lib/jxl/features/upsampling.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module JXL
+  module Features
+    module Upsampling
+      WEIGHTS_PATH = File.join(__dir__, "upsampling_weights.bin")
+      COUNTS = [15, 55, 210].freeze
+
+      module_function
+
+      def apply(channels, frame, transform_data)
+        factor = frame.upsampling
+        return channels if factor == 1
+
+        channels.each_with_index.map do |channel, index|
+          channel_factor = index < 3 ? factor : frame.extra_channel_upsampling[index - 3]
+          next channel if channel_factor == 1
+
+          weight_index = channel_factor.bit_length - 2
+          weights = transform_data.weights[weight_index] || default_weights[weight_index]
+          upsample(channel, channel_factor, weights, frame.width, frame.height)
+        end
+      end
+
+      def upsample(source, factor, weights, width = source.width * factor, height = source.height * factor)
+        kernels = kernels(factor, weights)
+        output = Plane.new(width, height)
+        source.height.times do |y|
+          source.width.times do |x|
+            neighbourhood = Array.new(25) do |index|
+              sample(source, x + (index % 5) - 2, y + (index / 5) - 2)
+            end
+            minimum, maximum = neighbourhood.minmax
+            factor.times do |oy|
+              target_y = (y * factor) + oy
+              next if target_y >= height
+
+              factor.times do |ox|
+                target_x = (x * factor) + ox
+                next if target_x >= width
+
+                value = 25.times.sum { |index| neighbourhood[index] * kernels[(oy * factor) + ox][index] }
+                output[target_x, target_y] = Num.clamp(value, minimum, maximum)
+              end
+            end
+          end
+        end
+        output
+      end
+
+      def kernels(factor, weights)
+        half = factor / 2
+        output = Array.new(factor * factor) { Array.new(25) }
+        half.times do |ky|
+          half.times do |kx|
+            5.times do |py|
+              5.times do |px|
+                i, j = [(5 * kx) + px, (5 * ky) + py].minmax
+                weight = weights[(5 * half * i) - (i * (i - 1) / 2) + j - i]
+                set_symmetric!(output, factor, kx, ky, px, py, weight)
+              end
+            end
+          end
+        end
+        output
+      end
+
+      def set_symmetric!(kernels, factor, kx, ky, px, py, weight)
+        kernels[(ky * factor) + kx][(py * 5) + px] = weight
+        kernels[(ky * factor) + factor - 1 - kx][(py * 5) + 4 - px] = weight
+        kernels[((factor - 1 - ky) * factor) + kx][((4 - py) * 5) + px] = weight
+        kernels[((factor - 1 - ky) * factor) + factor - 1 - kx][((4 - py) * 5) + 4 - px] = weight
+      end
+      private_class_method :set_symmetric!
+
+      def default_weights
+        @default_weights ||= begin
+          values = File.binread(WEIGHTS_PATH).unpack("e*")
+          offset = 0
+          COUNTS.map { |count| values.slice(offset, count).tap { offset += count }.freeze }.freeze
+        end
+      end
+      private_class_method :default_weights
+
+      def sample(plane, x, y)
+        plane[mirror(x, plane.width), mirror(y, plane.height)]
+      end
+      private_class_method :sample
+
+      def mirror(value, size)
+        return 0 if size == 1
+
+        value %= 2 * size
+        value < size ? value : (2 * size) - value - 1
+      end
+      private_class_method :mirror
+    end
+  end
+end

data/lib/jxl/filter/epf.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module JXL
+  module Filter
+    module EPF
+      INV_SIGMA_NUM = -1.17157287525381
+      MIN_SIGMA = -3.9052429175127
+      PLUS = [[0, 0], [-1, 0], [0, -1], [1, 0], [0, 1]].freeze
+      CROSS = [[-1, 0], [0, -1], [0, 1], [1, 0]].freeze
+      WIDE = [[-2, 0], [-1, -1], [-1, 0], [-1, 1], [0, -2], [0, -1],
+              [0, 1], [0, 2], [1, -1], [1, 0], [1, 1], [2, 0]].freeze
+
+      module_function
+
+      def apply(channels, loop_filter, global, lf_group)
+        return channels if loop_filter.epf_iterations.zero?
+
+        sigma = sigma_map(loop_filter, global, lf_group)
+        apply_filter(channels, sigma, loop_filter)
+      end
+
+      def apply_modular(channels, loop_filter)
+        return channels if loop_filter.epf_iterations.zero?
+
+        sigma = Plane.new(Num.ceil_div(channels.first.width, 8), Num.ceil_div(channels.first.height, 8),
+                          INV_SIGMA_NUM / loop_filter.epf_sigma_for_modular)
+        apply_filter(channels, sigma, loop_filter)
+      end
+
+      def apply_filter(channels, sigma, loop_filter)
+        output = channels
+        output = filter(output, sigma, loop_filter, WIDE, PLUS, loop_filter.epf_sigma_scale[0]) \
+          if loop_filter.epf_iterations >= 3
+        output = filter(output, sigma, loop_filter, CROSS, PLUS, 1.0) if loop_filter.epf_iterations >= 1
+        if loop_filter.epf_iterations >= 2
+          output = filter(output, sigma, loop_filter, CROSS, [[0, 0]], loop_filter.epf_sigma_scale[1])
+        end
+        output
+      end
+      private_class_method :apply_filter
+
+      def sigma_map(loop_filter, global, lf_group)
+        width = lf_group.quant_field.width
+        height = lf_group.quant_field.height
+        output = Plane.new(width, height)
+        height.times do |y|
+          width.times do |x|
+            index = (y * width) + x
+            next unless lf_group.strategy_first[index]
+
+            strategy = lf_group.strategies[index]
+            quant = lf_group.quant_field[x, y]
+            base = loop_filter.epf_quant_mul / (global.quantizer.scale * quant * INV_SIGMA_NUM)
+            strategy.blocks_y.times do |dy|
+              strategy.blocks_x.times do |dx|
+                sharpness = lf_group.sharpness[x + dx, y + dy]
+                value = [base * loop_filter.epf_sharpness[sharpness], -1e-4].min
+                output[x + dx, y + dy] = 1.0 / value
+              end
+            end
+          end
+        end
+        output
+      end
+
+      def filter(channels, sigma, loop_filter, neighbours, patch, sigma_scale) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+        sources = channels.first(3)
+        grayscale = sources[0].equal?(sources[1]) && sources[0].equal?(sources[2])
+        filtered_sources = grayscale ? sources.first(1) : sources
+        scales = grayscale ? [loop_filter.epf_channel_scale.sum] : loop_filter.epf_channel_scale
+        outputs = filtered_sources.map { Plane.new(_1.width, _1.height) }
+        sources[0].height.times do |y|
+          sources[0].width.times do |x|
+            inv_sigma = sigma[x / 8, y / 8]
+            if inv_sigma < MIN_SIGMA
+              outputs.each_index { |c| outputs[c][x, y] = filtered_sources[c][x, y] }
+              next
+            end
+
+            border = [x % 8, y % 8].any? { _1.zero? || _1 == 7 }
+            multiplier = 1.65 * sigma_scale
+            multiplier *= loop_filter.epf_border_sad_mul if border
+            weighted = filtered_sources.map { _1[x, y] }
+            total = 1.0
+            neighbours.each do |dx, dy|
+              sad = patch_sad(filtered_sources, x, y, dx, dy, patch, scales)
+              weight = [1.0 + (sad * inv_sigma * multiplier), 0.0].max
+              total += weight
+              weighted.each_index { |c| weighted[c] += weight * sample(filtered_sources[c], x + dx, y + dy) }
+            end
+            outputs.each_index { |c| outputs[c][x, y] = weighted[c] / total }
+          end
+        end
+        (grayscale ? Array.new(3, outputs.first) : outputs) + channels.drop(3)
+      end
+      private_class_method :filter
+
+      def patch_sad(channels, x, y, dx, dy, patch, scales)
+        channels.each_with_index.sum do |plane, channel|
+          patch.sum do |px, py|
+            (sample(plane, x + px, y + py) - sample(plane, x + dx + px, y + dy + py)).abs
+          end * scales[channel]
+        end
+      end
+      private_class_method :patch_sad
+
+      def sample(plane, x, y) = plane[mirror(x, plane.width), mirror(y, plane.height)]
+      private_class_method :sample
+
+      def mirror(value, size)
+        return 0 if size == 1
+
+        value %= 2 * size
+        value < size ? value : (2 * size) - value - 1
+      end
+      private_class_method :mirror
+    end
+  end
+end

data/lib/jxl/filter/gaborish.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module JXL
+  module Filter
+    module Gaborish
+      module_function
+
+      def apply(channels, loop_filter)
+        return channels unless loop_filter.gaborish
+
+        channels.first(3).each_with_index.map do |plane, channel|
+          convolve(plane, loop_filter.gaborish_weights[channel])
+        end + channels.drop(3)
+      end
+
+      def convolve(source, weights)
+        side, diagonal = weights
+        normalization = 1.0 / (1.0 + (4 * (side + diagonal)))
+        output = Plane.new(source.width, source.height)
+        source.height.times do |y|
+          source.width.times do |x|
+            sides = sample(source, x - 1, y) + sample(source, x + 1, y) +
+                    sample(source, x, y - 1) + sample(source, x, y + 1)
+            diagonals = sample(source, x - 1, y - 1) + sample(source, x + 1, y - 1) +
+                        sample(source, x - 1, y + 1) + sample(source, x + 1, y + 1)
+            output[x, y] = (source[x, y] + (side * sides) + (diagonal * diagonals)) * normalization
+          end
+        end
+        output
+      end
+
+      def sample(plane, x, y) = plane[Num.clamp(x, 0, plane.width - 1), Num.clamp(y, 0, plane.height - 1)]
+      private_class_method :sample
+    end
+  end
+end

data/lib/jxl/frame/toc.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module JXL
+  class Frame
+    TOC_DISTRIBUTIONS = [Bit::Field.bits(10), Bit::Field.bits_offset(14, 1024),
+                         Bit::Field.bits_offset(22, 17_408), Bit::Field.bits_offset(30, 4_211_712)].freeze
+
+    TOC = Data.define(:sizes, :offsets, :total_size, :permutation) do
+      def self.read(reader, count)
+        raise ResourceLimitError, "too many TOC entries" unless count.between?(1, 65_536)
+
+        permutation = Bit::Field.read_bool(reader) ? Entropy::Permutation.read(reader, count) : []
+
+        reader.zero_pad_to_byte
+        sizes = Array.new(count) { Bit::Field.u32(reader, *TOC_DISTRIBUTIONS) }
+        reader.zero_pad_to_byte
+        offset = 0
+        offsets = sizes.map do |size|
+          current = offset
+          offset += size
+          current
+        end
+        unless permutation.empty?
+          sizes = permutation.map { |index| sizes.fetch(index) }
+          offsets = permutation.map { |index| offsets.fetch(index) }
+        end
+        new(sizes:, offsets:, total_size: offset, permutation:)
+      end
+    end
+  end
+end