jxl 1.0.0

data/lib/jxl/modular/stream.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module JXL
+  module Modular
+    StreamState = Data.define(:tree, :entropy)
+    StreamResult = Data.define(:channels, :header)
+
+    module Stream
+      module_function
+
+      def read_global_state(reader, max_nodes: 1 << 20)
+        return StreamState.new(tree: nil, entropy: nil) unless Bit::Field.read_bool(reader)
+
+        tree = MATree.read(reader, max_nodes:)
+        StreamState.new(tree:, entropy: Entropy::Decoder.read(reader, tree.leaf_count, defer_state: true))
+      end
+
+      def decode(reader, shapes, state:, stream_id:, metadata:, max_nodes: 1 << 20)
+        return StreamResult.new(channels: [], header: nil) if shapes.empty?
+
+        original_shapes = shapes.map(&:dup)
+        header = GroupHeader.read(reader)
+        shapes, = TransformOps.encoded_shapes_for(shapes.map(&:dup), header.transforms)
+        tree, entropy = code(reader, header, state, shapes, max_nodes)
+        decoder = entropy.fork(reader, distance_multiplier: shapes.map(&:first).max)
+        channels = Decoder.decode_channels(decoder, tree, header.weighted, shapes, stream_id)
+        decoder.final_state!
+        Decoder.inverse_transforms!(channels, header, metadata)
+        unless channels.map { [_1.width, _1.height] } == original_shapes
+          raise CorruptError, "modular transforms changed the requested stream shape"
+        end
+
+        StreamResult.new(channels:, header:)
+      end
+
+      def code(reader, header, state, shapes, max_nodes)
+        if header.use_global_tree
+          raise CorruptError, "missing global MA tree" unless state.tree && state.entropy
+
+          return [state.tree, state.entropy]
+        end
+
+        limit = [max_nodes, 1024 + shapes.sum { |width, height| width * height }].min
+        tree = MATree.read(reader, max_nodes: limit)
+        [tree, Entropy::Decoder.read(reader, tree.leaf_count, defer_state: true)]
+      end
+    end
+  end
+end

data/lib/jxl/modular/transform.rb

@@ -0,0 +1,235 @@
+# frozen_string_literal: true
+
+module JXL
+  module Modular
+    module TransformOps
+      module_function
+
+      DELTAS = [
+        [0, 0, 0], [4, 4, 4], [11, 0, 0], [0, 0, -13], [0, -12, 0], [-10, -10, -10],
+        [-18, -18, -18], [-27, -27, -27], [-18, -18, 0], [0, 0, -32], [-32, 0, 0], [-37, -37, -37],
+        [0, -32, -32], [24, 24, 45], [50, 50, 50], [-45, -24, -24], [-24, -45, -45], [0, -24, -24],
+        [-34, -34, 0], [-24, 0, -24], [-45, -45, -24], [64, 64, 64], [-32, 0, -32], [0, -32, 0],
+        [-32, 0, 32], [-24, -45, -24], [45, 24, 45], [24, -24, -45], [-45, -24, 24], [80, 80, 80],
+        [64, 0, 0], [0, 0, -64], [0, -64, -64], [-24, -24, 45], [96, 96, 96], [64, 64, 0],
+        [45, -24, -24], [34, -34, 0], [112, 112, 112], [24, -45, -45], [45, 45, -24], [0, -32, 32],
+        [24, -24, 45], [0, 96, 96], [45, -24, 24], [24, -45, -24], [-24, -45, 24], [0, -64, 0],
+        [96, 0, 0], [128, 128, 128], [64, 0, 64], [144, 144, 144], [96, 96, 0], [-36, -36, 36],
+        [45, -24, -45], [45, -45, -24], [0, 0, -96], [0, 128, 128], [0, 96, 0], [45, 24, -45],
+        [-128, 0, 0], [24, -45, 24], [-45, 24, -45], [64, 0, -64], [64, -64, -64], [96, 0, 96],
+        [45, -45, 24], [24, 45, -45], [64, 64, -64], [128, 128, 0], [0, 0, -128], [-24, 45, -45]
+      ].freeze
+
+      def encoded_shapes(width, height, count, transforms)
+        shapes = Array.new(count) { [width, height] }
+        shifts = Array.new(count) { [0, 0] }
+        encoded_shapes_for(shapes, transforms, shifts:)
+      end
+
+      def encoded_shapes_for(shapes, transforms, shifts: Array.new(shapes.length) { [0, 0] }, meta: 0)
+        transforms.each do |transform|
+          case transform.id
+          when 0 then validate_range!(shapes, transform.begin_channel, 3)
+          when 1 then meta = meta_palette!(shapes, shifts, meta, transform)
+          when 2 then meta = meta_squeeze!(shapes, shifts, meta, transform)
+          end
+        end
+        [shapes, meta, shifts]
+      end
+
+      def inverse!(channels, transform, weighted_header, bit_depth)
+        case transform.id
+        when 1 then inverse_palette!(channels, transform, weighted_header, bit_depth)
+        when 2 then inverse_squeeze!(channels, transform.squeezes)
+        end
+      end
+
+      def meta_palette!(shapes, shifts, meta, transform)
+        validate_range!(shapes, transform.begin_channel, transform.num_channels)
+        base = shapes.fetch(transform.begin_channel)
+        transform.num_channels.times do |i|
+          raise CorruptError, "palette channel dimensions differ" unless shapes[transform.begin_channel + i] == base
+        end
+        shapes.slice!(transform.begin_channel + 1, transform.num_channels - 1)
+        shifts.slice!(transform.begin_channel + 1, transform.num_channels - 1)
+        shapes.unshift([transform.num_colors + transform.num_deltas, transform.num_channels])
+        shifts.unshift([-1, -1])
+        transform.begin_channel >= meta ? meta + 1 : meta + 2 - transform.num_channels
+      end
+      private_class_method :meta_palette!
+
+      def meta_squeeze!(shapes, shifts, meta, transform)
+        transform.squeezes.replace(default_squeezes(shapes, meta)) if transform.squeezes.empty?
+        transform.squeezes.each do |squeeze|
+          validate_range!(shapes, squeeze.begin_channel, squeeze.num_channels)
+          finish = squeeze.begin_channel + squeeze.num_channels - 1
+          offset = squeeze.in_place ? finish + 1 : shapes.length
+          squeeze.num_channels.times do |i|
+            width, height = shapes.fetch(squeeze.begin_channel + i)
+            hshift, vshift = shifts.fetch(squeeze.begin_channel + i)
+            average = squeeze.horizontal ? [(width + 1) / 2, height] : [width, (height + 1) / 2]
+            residual = squeeze.horizontal ? [width / 2, height] : [width, height / 2]
+            hshift += 1 if squeeze.horizontal && hshift >= 0
+            vshift += 1 if !squeeze.horizontal && vshift >= 0
+            shapes[squeeze.begin_channel + i] = average
+            shifts[squeeze.begin_channel + i] = [hshift, vshift]
+            shapes.insert(offset + i, residual)
+            shifts.insert(offset + i, [hshift, vshift])
+          end
+          meta += squeeze.num_channels if squeeze.begin_channel < meta
+        end
+        meta
+      end
+      private_class_method :meta_squeeze!
+
+      def default_squeezes(shapes, meta)
+        count = shapes.length - meta
+        width, height = shapes.fetch(meta)
+        result = []
+        if count > 2 && shapes[meta + 1] == [width, height]
+          result << Squeeze.new(horizontal: true, in_place: false, begin_channel: meta + 1, num_channels: 2)
+          result << Squeeze.new(horizontal: false, in_place: false, begin_channel: meta + 1, num_channels: 2)
+        end
+        params = { in_place: true, begin_channel: meta, num_channels: count }
+        if width <= height && height > 8
+          result << Squeeze.new(horizontal: false, **params)
+          height = (height + 1) / 2
+        end
+        while width > 8 || height > 8
+          if width > 8
+            result << Squeeze.new(horizontal: true, **params)
+            width = (width + 1) / 2
+          end
+          if height > 8
+            result << Squeeze.new(horizontal: false, **params)
+            height = (height + 1) / 2
+          end
+        end
+        result
+      end
+      private_class_method :default_squeezes
+
+      def inverse_palette!(channels, transform, weighted_header, bit_depth)
+        palette = channels.fetch(0)
+        index = channels.fetch(transform.begin_channel + 1)
+        outputs = Array.new(transform.num_channels) { Plane.new(index.width, index.height) }
+        outputs.each_with_index do |output, channel|
+          weighted = Weighted.new(weighted_header, output.width) if transform.predictor == 6
+          output.height.times do |y|
+            output.width.times do |x|
+              palette_index = index[x, y]
+              value = palette_value(palette, palette_index, channel, [bit_depth, 24].min)
+              if palette_index < transform.num_deltas
+                guess = weighted&.predict(output, x, y) || Predictor.predict(transform.predictor, output, x, y)
+                value += guess
+              end
+              output[x, y] = value
+              weighted&.update(value, x)
+            end
+          end
+        end
+        channels[transform.begin_channel + 1] = outputs.shift
+        channels.insert(transform.begin_channel + 2, *outputs)
+        channels.shift
+      end
+      private_class_method :inverse_palette!
+
+      def palette_value(palette, index, channel, bit_depth)
+        if index.negative?
+          entry = -(index + 1) % (1 + (2 * (DELTAS.length - 1)))
+          value = DELTAS[(entry + 1) >> 1].fetch(channel, 0) * (entry.odd? ? 1 : -1)
+          return bit_depth > 8 ? value << (bit_depth - 8) : value
+        end
+        if index >= palette.width + 64
+          value = (index - palette.width - 64) / (5**channel) % 5
+          return (value * ((1 << bit_depth) - 1)) >> 2 if channel < 3
+        elsif index >= palette.width
+          return 0 if channel >= 3
+
+          value = ((index - palette.width) >> (channel * 2)) & 3
+          return ((value * ((1 << bit_depth) - 1)) >> 2) + (1 << [bit_depth - 3, 0].max)
+        end
+        palette[index, channel]
+      end
+      private_class_method :palette_value
+
+      def inverse_squeeze!(channels, squeezes)
+        squeezes.reverse_each do |squeeze|
+          finish = squeeze.begin_channel + squeeze.num_channels - 1
+          offset = squeeze.in_place ? finish + 1 : channels.length + squeeze.begin_channel - finish - 1
+          squeeze.num_channels.times do |i|
+            channel = squeeze.begin_channel + i
+            channels[channel] = unsqueeze(channels.fetch(channel), channels.fetch(offset + i), squeeze.horizontal)
+          end
+          channels.slice!(offset, squeeze.num_channels)
+        end
+      end
+      private_class_method :inverse_squeeze!
+
+      def unsqueeze(average, residual, horizontal)
+        output = Plane.new(horizontal ? average.width + residual.width : average.width,
+                           horizontal ? average.height : average.height + residual.height)
+        horizontal ? unsqueeze_horizontal!(output, average, residual) : unsqueeze_vertical!(output, average, residual)
+        output
+      end
+      private_class_method :unsqueeze
+
+      def unsqueeze_horizontal!(output, average, residual)
+        average.height.times do |y|
+          residual.width.times do |x|
+            avg = average[x, y]
+            following = x + 1 < average.width ? average[x + 1, y] : avg
+            tendency = smooth_tendency(x.zero? ? avg : output[(x * 2) - 1, y], avg, following)
+            diff = residual[x, y] + tendency
+            first = avg + Num.cdiv(diff, 2)
+            output[x * 2, y] = first
+            output[(x * 2) + 1, y] = first - diff
+          end
+          output[output.width - 1, y] = average[average.width - 1, y] if output.width.odd?
+        end
+      end
+      private_class_method :unsqueeze_horizontal!
+
+      def unsqueeze_vertical!(output, average, residual)
+        residual.height.times do |y|
+          average.width.times do |x|
+            avg = average[x, y]
+            following = y + 1 < average.height ? average[x, y + 1] : avg
+            tendency = smooth_tendency(y.zero? ? avg : output[x, (y * 2) - 1], avg, following)
+            diff = residual[x, y] + tendency
+            first = avg + Num.cdiv(diff, 2)
+            output[x, y * 2] = first
+            output[x, (y * 2) + 1] = first - diff
+          end
+        end
+        return unless output.height.odd?
+
+        average.width.times { |x| output[x, output.height - 1] = average[x, average.height - 1] }
+      end
+      private_class_method :unsqueeze_vertical!
+
+      def smooth_tendency(previous, average, following)
+        if average.between?(following, previous)
+          diff = Num.cdiv((4 * previous) - (3 * following) - average + 6, 12)
+          diff = (2 * (previous - average)) + 1 if diff - (diff & 1) > 2 * (previous - average)
+          diff = 2 * (average - following) if diff + (diff & 1) > 2 * (average - following)
+          diff
+        elsif average.between?(previous, following)
+          diff = Num.cdiv((4 * previous) - (3 * following) - average - 6, 12)
+          diff = (2 * (previous - average)) - 1 if diff + (diff & 1) < 2 * (previous - average)
+          diff = 2 * (average - following) if diff - (diff & 1) < 2 * (average - following)
+          diff
+        else
+          0
+        end
+      end
+      private_class_method :smooth_tendency
+
+      def validate_range!(channels, first, count)
+        valid = first && count.positive? && first + count <= channels.length
+        raise CorruptError, "transform channel range" unless valid
+      end
+      private_class_method :validate_range!
+    end
+  end
+end

data/lib/jxl/modular/weighted.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module JXL
+  module Modular
+    class Weighted
+      DIV_LOOKUP = Array.new(64) { |i| (1 << 24) / (i + 1) }.freeze
+
+      attr_reader :property
+
+      def initialize(header, width)
+        @header = header
+        @width = width
+        @stride = width + 2
+        @pred_errors = Array.new(4) { Array.new(@stride * 2, 0) }
+        @errors = Array.new(@stride * 2, 0)
+      end
+
+      def predict(plane, x, y) # rubocop:disable Metrics/AbcSize
+        n = Predictor.neighbors(plane, x, y)
+        positions(x, y)
+        weights = @pred_errors.each_with_index.map do |errors, i|
+          sum = Num.u32(errors[@pos_n] + errors[@pos_ne] + errors[@pos_nw])
+          error_weight(sum, @header.weights[i])
+        end
+
+        north, west, northeast, northwest, northnorth =
+          %i[top left topright topleft toptop].map { n.fetch(_1) << 3 }
+        error_west = x.zero? ? 0 : @errors[@current_row + x - 1]
+        error_north = @errors[@pos_n]
+        error_northwest = @errors[@pos_nw]
+        error_northeast = @errors[@pos_ne]
+        @property = [error_west, error_north, error_northwest, error_northeast].max_by(&:abs)
+
+        sum = error_north + error_west
+        p = @header.p
+        @predictions = [
+          west + northeast - north,
+          north - (((sum + error_northeast) * p[0]) >> 5),
+          west - (((sum + error_northwest) * p[1]) >> 5),
+          north - (((error_northwest * p[2]) + (error_north * p[3]) + (error_northeast * p[4]) +
+                    ((northnorth - north) * p[5]) + ((northwest - west) * p[6])) >> 5)
+        ]
+        @prediction = weighted_average(weights)
+        same_sign = ((error_north ^ error_west) | (error_north ^ error_northwest)).positive?
+        return (@prediction + 3) >> 3 if same_sign
+
+        @prediction = @prediction.clamp([west, northeast, north].min, [west, northeast, north].max)
+        (@prediction + 3) >> 3
+      end
+
+      def update(value, x)
+        scaled = value << 3
+        @errors[@current_row + x] = Num.i32(@prediction - scaled)
+        @pred_errors.each_with_index do |errors, i|
+          error = Num.u32(((@predictions[i] - scaled).abs + 3) >> 3)
+          errors[@current_row + x] = error
+          errors[@previous_row + x + 1] = Num.u32(errors[@previous_row + x + 1] + error)
+        end
+      end
+
+      private
+
+      def positions(x, y)
+        @current_row = y.odd? ? 0 : @stride
+        @previous_row = y.odd? ? @stride : 0
+        @pos_n = @previous_row + x
+        @pos_ne = x < @width - 1 ? @pos_n + 1 : @pos_n
+        @pos_nw = x.positive? ? @pos_n - 1 : @pos_n
+      end
+
+      def error_weight(error, max_weight)
+        shift = [(error + 1).bit_length - 6, 0].max
+        4 + ((max_weight * DIV_LOOKUP[error >> shift]) >> shift)
+      end
+
+      def weighted_average(weights)
+        log_weight = weights.sum.bit_length - 1
+        weights.map! { _1 >> (log_weight - 4) }
+        sum = weights.sum
+        ((weights.each_with_index.sum { |weight, i| @predictions[i] * weight } + (sum >> 1) - 1) *
+          DIV_LOOKUP[sum - 1]) >> 24
+      end
+    end
+  end
+end

data/lib/jxl/num.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module JXL
+  module Num
+    module_function
+
+    def cdiv(a, b)
+      quotient = a.abs / b.abs
+      a.negative? == b.negative? ? quotient : -quotient
+    end
+
+    def sar(value, bits) = value >> bits
+    def clamp(value, low, high) = value.clamp(low, high)
+    def u32(value) = value & 0xFFFF_FFFF
+
+    def i32(value)
+      value = u32(value)
+      value >= 0x8000_0000 ? value - 0x1_0000_0000 : value
+    end
+
+    def f32(value) = [value].pack("f").unpack1("f")
+    def unpack_signed(value) = (value >> 1) ^ -(value & 1)
+    def pack_signed(value) = value.negative? ? ((-value << 1) - 1) : (value << 1)
+
+    def ceil_log2(value)
+      raise ArgumentError, "value must be positive" unless value.positive?
+
+      (value - 1).bit_length
+    end
+
+    def ceil_div(value, divisor)
+      raise ArgumentError, "divisor must be positive" unless divisor.positive?
+
+      value.div(divisor) + (value.modulo(divisor).zero? ? 0 : 1)
+    end
+  end
+end

data/lib/jxl/plane.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module JXL
+  class Plane
+    attr_reader :width, :height, :data
+
+    def initialize(width, height, fill = 0)
+      unless valid_dimension?(width) && valid_dimension?(height)
+        raise ArgumentError, "dimensions must be non-negative integers"
+      end
+
+      @width = width
+      @height = height
+      @data = Array.new(width * height, fill)
+    end
+
+    def [](x, y) = @data.fetch(index(x, y))
+
+    def []=(x, y, value)
+      @data[index(x, y)] = value
+    end
+
+    def raw = @data
+
+    private
+
+    def valid_dimension?(value) = value.is_a?(Integer) && !value.negative?
+
+    def index(x, y)
+      raise IndexError, "pixel outside plane" unless x.between?(0, @width - 1) && y.between?(0, @height - 1)
+
+      (y * @width) + x
+    end
+  end
+end

data/lib/jxl/render/blender.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module JXL
+  module Render
+    module Blender
+      MODES = [1, 2, 4, 6, 3].freeze
+
+      module_function
+
+      def compose(foreground, frame, references, width, height)
+        colour_channels = foreground.channels.length - foreground.metadata.extra_channels.length
+        infos = Array.new(colour_channels, frame.blend) + frame.extra_channel_blends
+        background = infos.each_with_index.map do |info, channel|
+          source = references[info.source]&.channels&.[](channel)
+          copy_plane(source, width, height)
+        end
+        blends = infos.map do |info|
+          Features::PatchBlend.new(mode: MODES.fetch(info.mode), alpha_channel: info.alpha_channel,
+                                   clamp: info.clamp)
+        end
+        composite_region!(background, foreground.channels, blends, foreground.metadata,
+                          frame.origin_x, frame.origin_y, colour_channels)
+        Image.new(width:, height:, channels: background, metadata: foreground.metadata)
+      end
+
+      def copy_plane(source, width, height)
+        output = Plane.new(width, height, 0.0)
+        return output unless source
+
+        rows = [height, source.height].min
+        columns = [width, source.width].min
+        rows.times { |y| output.data[y * width, columns] = source.data[y * source.width, columns] }
+        output
+      end
+      private_class_method :copy_plane
+
+      def composite_region!(background, foreground, blends, metadata, origin_x, origin_y, colour_channels)
+        foreground.first.height.times do |y|
+          target_y = origin_y + y
+          next unless target_y.between?(0, background.first.height - 1)
+
+          foreground.first.width.times do |x|
+            target_x = origin_x + x
+            next unless target_x.between?(0, background.first.width - 1)
+
+            target = (target_y * background.first.width) + target_x
+            source = (y * foreground.first.width) + x
+            old = background.map { _1.data[target] }
+            new = foreground.map { _1.data[source] }
+            blends.each_index.reverse_each do |channel|
+              background[channel].data[target] = Features::Patches.blend_value(
+                old[channel], new[channel], blends[channel], old, new, metadata, colour_channels:, channel:
+              )
+            end
+          end
+        end
+      end
+      private_class_method :composite_region!
+    end
+  end
+end

data/lib/jxl/render/orientation.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module JXL
+  module Render
+    module Orientation
+      module_function
+
+      def apply(image)
+        orientation = image.metadata.orientation
+        return image if orientation == 1
+
+        width, height = orientation >= 5 ? [image.height, image.width] : [image.width, image.height]
+        channels = image.channels.map do |source|
+          Plane.new(width, height).tap do |target|
+            height.times do |y|
+              width.times do |x|
+                source_x, source_y = source_coordinates(x, y, source.width, source.height, orientation)
+                target[x, y] = source[source_x, source_y]
+              end
+            end
+          end
+        end
+        image.with(width:, height:, channels:)
+      end
+
+      def source_coordinates(x, y, width, height, orientation)
+        case orientation
+        when 1 then [x, y]
+        when 2 then [width - 1 - x, y]
+        when 3 then [width - 1 - x, height - 1 - y]
+        when 4 then [x, height - 1 - y]
+        when 5 then [y, x]
+        when 6 then [y, height - 1 - x]
+        when 7 then [width - 1 - y, height - 1 - x]
+        when 8 then [width - 1 - y, x]
+        else raise CorruptError, "invalid orientation"
+        end
+      end
+      private_class_method :source_coordinates
+    end
+  end
+end

data/lib/jxl/trace.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module JXL
+  module Trace
+    module_function
+
+    def br(bits, value, position) = write("BR n=#{bits} val=#{value} pos=#{position}")
+    def field(name, value) = write("FIELD name=#{name} val=#{value}")
+    def symbol(context, value) = write("SYM ctx=#{context} val=#{value}")
+    def token(context, value) = write_to("JXL_TOKEN_TRACE_FILE", "TOK ctx=#{context} token=#{value}")
+
+    def write(line)
+      return unless (path = ENV.fetch("JXL_TRACE_FILE", nil))
+
+      (@file ||= File.open(path, "w")).puts(line)
+      @file.flush
+    end
+
+    def write_to(variable, line)
+      return unless (path = ENV.fetch(variable, nil))
+
+      (@files ||= {})[path] ||= File.open(path, "w")
+      @files[path].puts(line)
+      @files[path].flush
+    end
+
+    def close
+      @file&.close
+      @file = nil
+      @files&.each_value(&:close)
+      @files = nil
+    end
+  end
+end
+
+at_exit { JXL::Trace.close }

data/lib/jxl/vardct/ac_strategy.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module JXL
+  module VarDCT
+    AC_STRATEGY_NAMES = %i[
+      dct8x8 identity dct2x2 dct4x4 dct16x16 dct32x32 dct16x8 dct8x16 dct32x8 dct8x32 dct32x16 dct16x32
+      dct4x8 dct8x4 afv0 afv1 afv2 afv3 dct64x64 dct64x32 dct32x64 dct128x128 dct128x64 dct64x128
+      dct256x256 dct256x128 dct128x256
+    ].freeze
+    BLOCK_WIDTHS = [1, 1, 1, 1, 2, 4, 1, 2, 1, 4, 2, 4, 1, 1, 1, 1, 1, 1, 8, 4, 8, 16, 8, 16, 32, 16, 32].freeze
+    BLOCK_HEIGHTS = [1, 1, 1, 1, 2, 4, 2, 1, 4, 1, 4, 2, 1, 1, 1, 1, 1, 1, 8, 8, 4, 16, 16, 8, 32, 32, 16].freeze
+    STRATEGY_ORDERS = [0, 1, 1, 1, 2, 3, 4, 4, 5, 5, 6, 6, 1, 1, 1, 1, 1, 1, 7, 8, 8, 9, 10, 10, 11, 12, 12].freeze
+
+    AcStrategy = Data.define(:id, :name, :blocks_x, :blocks_y) do
+      def self.[](id)
+        raise CorruptError, "invalid AC strategy" unless id.between?(0, AC_STRATEGY_NAMES.length - 1)
+
+        new(id:, name: AC_STRATEGY_NAMES[id], blocks_x: BLOCK_WIDTHS[id], blocks_y: BLOCK_HEIGHTS[id])
+      end
+
+      def width = blocks_x * 8
+      def height = blocks_y * 8
+      def coefficient_count = width * height
+      def order = STRATEGY_ORDERS[id]
+      def log2_blocks = (blocks_x * blocks_y).bit_length - 1
+
+      def natural_order
+        columns, rows = [blocks_x, blocks_y].minmax.reverse
+        ratio = columns / rows
+        ratio_mask = ratio - 1
+        ratio_shift = ratio.bit_length - 1
+        result = Array.new(coefficient_count)
+        current = columns * rows
+        (0...(columns * 8)).each do |diagonal|
+          0.upto(diagonal) do |j|
+            x, y = diagonal.odd? ? [diagonal - j, j] : [j, diagonal - j]
+            next unless y.nobits?(ratio_mask)
+
+            y >>= ratio_shift
+            value = if x < columns && y < rows
+                      (y * columns) + x
+                    else
+                      current.tap { current += 1 }
+                    end
+            result[value] = (y * columns * 8) + x
+          end
+        end
+        ((columns * 8) - 1).downto(1) do |ip|
+          diagonal = ip - 1
+          0.upto(diagonal) do |j|
+            x = (columns * 8) - 1 - (diagonal - j)
+            y = (columns * 8) - 1 - j
+            x, y = y, x if diagonal.odd?
+            next unless y.nobits?(ratio_mask)
+
+            y >>= ratio_shift
+            result[current] = (y * columns * 8) + x
+            current += 1
+          end
+        end
+        result
+      end
+    end
+  end
+end