jxl 1.0.0

data/lib/jxl/vardct/block_context_map.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module JXL
+  module VarDCT
+    DEFAULT_BLOCK_CONTEXT_MAP = [
+      0, 1, 2, 2, 3, 3, 4, 5, 6, 6, 6, 6, 6,
+      7, 8, 9, 9, 10, 11, 12, 13, 14, 14, 14, 14, 14,
+      7, 8, 9, 9, 10, 11, 12, 13, 14, 14, 14, 14, 14
+    ].freeze
+    BLOCK_DC_DISTRIBUTION = [Bit::Field.bits(4), Bit::Field.bits_offset(8, 16),
+                             Bit::Field.bits_offset(16, 272), Bit::Field.bits_offset(32, 65_808)].freeze
+    BLOCK_QF_DISTRIBUTION = [Bit::Field.bits(2), Bit::Field.bits_offset(3, 4),
+                             Bit::Field.bits_offset(5, 12), Bit::Field.bits_offset(8, 44)].freeze
+
+    BlockContextMap = Data.define(:dc_thresholds, :qf_thresholds, :context_map,
+                                  :num_contexts, :num_dc_contexts) do
+      def self.read(reader)
+        return defaults if Bit::Field.read_bool(reader)
+
+        dc = Array.new(3) do
+          Array.new(reader.read(4)) { Num.unpack_signed(Bit::Field.u32(reader, *BLOCK_DC_DISTRIBUTION)) }
+        end
+        num_dc = dc.reduce(1) { |total, thresholds| total * (thresholds.length + 1) }
+        qf = Array.new(reader.read(4)) { Bit::Field.u32(reader, *BLOCK_QF_DISTRIBUTION) + 1 }
+        raise CorruptError, "block context map is too large" if num_dc * (qf.length + 1) > 64
+
+        read_map(reader, dc, qf, num_dc)
+      end
+
+      def self.defaults
+        new(dc_thresholds: Array.new(3) { [] }, qf_thresholds: [], context_map: DEFAULT_BLOCK_CONTEXT_MAP,
+            num_contexts: 15, num_dc_contexts: 1)
+      end
+
+      def self.read_map(reader, dc, qf, num_dc)
+        map = Entropy::Decoder.decode_context_map(reader, 3 * 13 * num_dc * (qf.length + 1))
+        raise CorruptError, "too many block contexts" if map.max >= 16
+
+        new(dc_thresholds: dc, qf_thresholds: qf, context_map: map,
+            num_contexts: map.max + 1, num_dc_contexts: num_dc)
+      end
+      private_class_method :read_map
+
+      def context(dc_index, quant, order, channel)
+        quant_index = qf_thresholds.count { quant > _1 }
+        index = ((channel < 2 ? channel ^ 1 : 2) * 13) + order
+        context_map.fetch((((index * (qf_thresholds.length + 1)) + quant_index) * num_dc_contexts) + dc_index)
+      end
+
+      def nonzero_context(nonzeros, block_context)
+        nonzeros = 64 if nonzeros >= 64
+        bucket = nonzeros < 8 ? nonzeros : 4 + (nonzeros / 2)
+        (bucket * num_contexts) + block_context
+      end
+
+      def coefficient_context_offset(block_context)
+        (num_contexts * 37) + (458 * block_context)
+      end
+
+      def ac_context_count = num_contexts * (37 + 458)
+    end
+  end
+end

data/lib/jxl/vardct/chroma_from_luma.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module JXL
+  module VarDCT
+    CFL_FACTOR_DISTRIBUTION = [Bit::Field.val(84), Bit::Field.val(256),
+                               Bit::Field.bits_offset(8, 2), Bit::Field.bits_offset(16, 258)].freeze
+
+    ChromaFromLuma = Data.define(:color_factor, :base_x, :base_b, :dc_x, :dc_b) do
+      def self.read_dc(reader)
+        return new(color_factor: 84, base_x: 0.0, base_b: 1.0, dc_x: 0, dc_b: 0) if Bit::Field.read_bool(reader)
+
+        factor = Bit::Field.u32(reader, *CFL_FACTOR_DISTRIBUTION)
+        raise CorruptError, "zero chroma correlation factor" if factor.zero?
+
+        base_x = Bit::Field.f16(reader)
+        base_b = Bit::Field.f16(reader)
+        raise CorruptError, "chroma correlation is out of range" if base_x.abs > 4.0 || base_b.abs > 4.0
+
+        new(color_factor: factor, base_x:, base_b:, dc_x: reader.read(8) - 128, dc_b: reader.read(8) - 128)
+      end
+
+      def dc_factors = [base_x + dc_x.fdiv(color_factor), 0.0, base_b + dc_b.fdiv(color_factor)]
+      def x_ratio(factor) = base_x + factor.fdiv(color_factor)
+      def b_ratio(factor) = base_b + factor.fdiv(color_factor)
+    end
+  end
+end

data/lib/jxl/vardct/coeff_order.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module JXL
+  module VarDCT
+    module CoeffOrder
+      ORDER_REPRESENTATIVES = [0, 1, 4, 5, 6, 8, 10, 18, 19, 21, 22, 24, 25].freeze
+
+      module_function
+
+      def read(reader, used_orders, used_strategies)
+        decoder = Entropy::Decoder.read(reader, 8) unless used_orders.zero?
+        used_order_ids = used_strategies.map { AcStrategy[_1].order }.uniq
+        result = {}
+        ORDER_REPRESENTATIVES.each_with_index do |strategy_id, order|
+          next if !used_order_ids.include?(order) && used_orders[order].zero?
+
+          strategy = AcStrategy[strategy_id]
+          natural = strategy.natural_order
+          3.times do |channel|
+            permutation = if used_orders[order].zero?
+                            natural
+                          else
+                            Entropy::Permutation.read_with_decoder(
+                              decoder, natural.length, skip: strategy.blocks_x * strategy.blocks_y
+                            ).map { natural[_1] }
+                          end
+            result[[order, channel]] = permutation if used_order_ids.include?(order)
+          end
+        end
+        decoder&.final_state!
+        result
+      end
+    end
+  end
+end

data/lib/jxl/vardct/decoder.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module JXL
+  module VarDCT
+    module Decoder
+      module_function
+
+      def decode(parsed, references: [], dc_frames: [])
+        global, lf, pass = if parsed.sections.one?
+                             read_single_section(parsed, references, dc_frames)
+                           else
+                             read_grouped_sections(parsed, references, dc_frames)
+                           end
+        frame = parsed.frame_header
+        if frame.flags.nobits?(128 | 32) && frame.max_hshift.zero? && frame.max_vshift.zero?
+          LFGroup.smooth!(lf, global.quantizer.dc_steps(global.dequant))
+        end
+        channels = Reconstructor.reconstruct(parsed.frame_header, global, lf, pass,
+                                             quant_biases: parsed.transform_data.opsin.quant_biases)
+        channels.concat(normalize_extra_channels(global.extra_channels, parsed.basic_info.metadata))
+        channels = Filter::Gaborish.apply(channels, parsed.frame_header.loop_filter)
+        channels = Filter::EPF.apply(channels, parsed.frame_header.loop_filter, global, lf)
+        channels = Features::Patches.apply(channels, global.patches, references, parsed.basic_info.metadata)
+        channels = Features::Splines.apply(channels, global.splines, global.chroma_from_luma)
+        channels = Features::Upsampling.apply(channels, parsed.frame_header, parsed.transform_data)
+        channels = Features::Noise.apply(channels, global.noise, global.chroma_from_luma)
+        channels = convert_colour(channels, parsed)
+        if parsed.basic_info.metadata.colour_encoding.colour_space == 1
+          channels = [channels.first] + channels.last(parsed.basic_info.metadata.extra_channels.length)
+        end
+        channels.map! { crop(_1, parsed.frame_header.width, parsed.frame_header.height) }
+        Image.new(width: parsed.frame_header.width, height: parsed.frame_header.height,
+                  channels:, metadata: parsed.basic_info.metadata)
+      end
+
+      def read_single_section(parsed, references, dc_frames)
+        frame = parsed.frame_header
+        reader = Bit::Reader.new(parsed.sections.first)
+        global = LFGlobal.read(reader, frame, parsed.basic_info.metadata, references:)
+        lf = LFGroup.read(reader, frame, parsed.basic_info.metadata, global, dc_frame: dc_frames[frame.dc_level])
+        hf = HFGlobal.read(reader, frame, global, [lf], metadata: parsed.basic_info.metadata)
+        passes = frame.passes.count.times.map { |pass| PassGroup.read(reader, frame, global, lf, hf, pass_index: pass) }
+        global = finish_extra_channels(global)
+        [global, lf, PassGroup.merge(passes)]
+      end
+      private_class_method :read_single_section
+
+      def read_grouped_sections(parsed, references, dc_frames)
+        frame = parsed.frame_header
+        dc_groups = dc_group_count(frame)
+        global = LFGlobal.read(section_reader(parsed, 0), frame, parsed.basic_info.metadata, references:)
+        lf_groups = Array.new(dc_groups) do |group|
+          LFGroup.read(section_reader(parsed, 1 + group), frame, parsed.basic_info.metadata, global,
+                       group_index: group, group_count: dc_groups, dc_frame: dc_frames[frame.dc_level])
+        end
+        lf = LFGroup.merge(lf_groups, frame)
+        hf = HFGlobal.read(section_reader(parsed, 1 + dc_groups), frame, global, lf_groups,
+                           metadata: parsed.basic_info.metadata)
+        group_dim = 128 << frame.group_size_shift
+        count = Num.ceil_div(frame.encoded_width, group_dim) * Num.ceil_div(frame.encoded_height, group_dim)
+        blocks = count.times.flat_map do |group|
+          passes = frame.passes.count.times.map do |pass|
+            reader = section_reader(parsed, 2 + dc_groups + (pass * count) + group)
+            PassGroup.read(reader, frame, global, lf, hf, pass_index: pass, group_index: group)
+          end
+          PassGroup.merge(passes).blocks
+        end
+        global = finish_extra_channels(global)
+        [global, lf, PassGroup.new(blocks:)]
+      end
+      private_class_method :read_grouped_sections
+
+      def finish_extra_channels(global)
+        return global unless global.modular_group
+
+        global.with(extra_channels: Modular::Decoder.finish_grouped_stream(global.modular_group))
+      end
+      private_class_method :finish_extra_channels
+
+      def dc_group_count(frame)
+        group_dim = 128 << frame.group_size_shift
+        Num.ceil_div(frame.blocks_width, group_dim) * Num.ceil_div(frame.blocks_height, group_dim)
+      end
+      private_class_method :dc_group_count
+
+      def section_reader(parsed, index) = Bit::Reader.new(parsed.sections.fetch(index))
+      private_class_method :section_reader
+
+      def convert_colour(channels, parsed)
+        frame = parsed.frame_header
+        return Color::YCbCr.to_rgb(channels, frame) if frame.colour_transform == :ycbcr
+        return channels unless frame.colour_transform == :xyb
+
+        opsin = parsed.transform_data.opsin
+        linear = Color::Opsin.to_linear(channels, opsin,
+                                        intensity_target: parsed.basic_info.metadata.tone_mapping.intensity_target)
+        encoding = parsed.basic_info.metadata.colour_encoding
+        return linear if encoding.want_icc
+
+        Color::Transfer.from_linear!(
+          linear, encoding.transfer_function, gamma: encoding.gamma,
+                                              intensity_target: parsed.basic_info.metadata.tone_mapping.intensity_target
+        )
+      end
+      private_class_method :convert_colour
+
+      def normalize_extra_channels(channels, metadata)
+        channels.each_with_index.map do |plane, index|
+          depth = metadata.extra_channels[index].bit_depth
+          unless depth.floating_point
+            scale = 1.0 / ((1 << depth.bits_per_sample) - 1)
+            next Plane.new(plane.width, plane.height).tap { _1.data.replace(plane.data.map { |value| value * scale }) }
+          end
+
+          unless depth.bits_per_sample == 32 && depth.exponent_bits == 8
+            raise UnsupportedFeatureError, "non-binary32 extra channel"
+          end
+
+          Plane.new(plane.width, plane.height).tap do |output|
+            output.data.replace(plane.data.map { [Num.u32(_1)].pack("L<").unpack1("e") })
+          end
+        end
+      end
+      private_class_method :normalize_extra_channels
+
+      def crop(source, width, height)
+        return source if source.width == width && source.height == height
+
+        Plane.new(width, height).tap do |output|
+          height.times { |y| output.data[y * width, width] = source.data[y * source.width, width] }
+        end
+      end
+      private_class_method :crop
+    end
+  end
+end

data/lib/jxl/vardct/dequant.rb

@@ -0,0 +1,284 @@
+# frozen_string_literal: true
+
+module JXL
+  module VarDCT
+    class Dequant # rubocop:disable Metrics/ClassLength
+      DEFAULT_DC = [1.0 / 4096, 1.0 / 512, 1.0 / 256].freeze
+      TABLE_WIDTHS = [1, 1, 1, 1, 2, 4, 1, 1, 2, 1, 1, 8, 4, 16, 8, 32, 16].freeze
+      TABLE_HEIGHTS = [1, 1, 1, 1, 2, 4, 2, 4, 4, 1, 1, 8, 8, 16, 16, 32, 32].freeze
+      STRATEGY_TABLE = [0, 1, 2, 3, 4, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 10, 10,
+                        11, 12, 12, 13, 14, 14, 15, 16, 16].freeze
+      TABLE_LENGTHS = TABLE_WIDTHS.zip(TABLE_HEIGHTS).map { |width, height| 3 * width * height * 64 }.freeze
+      TABLE_OFFSETS = TABLE_LENGTHS.each_with_object([0]) do |length, offsets|
+        offsets << (offsets.last + length)
+      end.freeze
+      TABLE_PATH = File.join(__dir__, "default_dequant.bin.z")
+
+      attr_reader :dc
+
+      def initialize(dc = DEFAULT_DC)
+        @dc = dc
+        @tables = nil
+      end
+
+      def self.read_dc(reader)
+        return new if Bit::Field.read_bool(reader)
+
+        dc = Array.new(3) { Bit::Field.f16(reader) / 128.0 }
+        raise CorruptError, "invalid DC quantization" unless dc.all?(&:positive?)
+
+        new(dc.freeze)
+      end
+
+      def matrix(strategy, channel)
+        raise ArgumentError, "invalid dequant channel" unless channel.between?(0, 2)
+
+        table = STRATEGY_TABLE.fetch(strategy.id)
+        channel_length = TABLE_LENGTHS.fetch(table) / 3
+        offset = TABLE_OFFSETS.fetch(table) + (channel * channel_length)
+        (@tables || self.class.default_tables).slice(offset, channel_length)
+      end
+
+      def read_matrices!(reader, state:, metadata:, stream_base:)
+        return self if Bit::Field.read_bool(reader)
+
+        @tables = self.class.default_tables.dup
+        TABLE_WIDTHS.each_index do |table|
+          mode = reader.read(3)
+          next if mode.zero?
+
+          values = if mode == 7
+                     read_raw_matrix(reader, state, metadata, stream_base + table, table)
+                   else
+                     self.class.read_parametric_matrix(reader, mode, table)
+                   end
+          @tables[TABLE_OFFSETS[table], TABLE_LENGTHS[table]] = values
+        end
+        self
+      end
+
+      def read_raw_matrix(reader, state, metadata, stream_id, table)
+        denominator = Bit::Field.f16(reader)
+        raise CorruptError, "invalid raw quantization denominator" unless denominator.positive?
+
+        width = TABLE_WIDTHS[table] * 8
+        height = TABLE_HEIGHTS[table] * 8
+        result = Modular::Stream.decode(
+          reader, Array.new(3) { [width, height] }, state:, stream_id:, metadata:
+        )
+        values = result.channels.flat_map(&:data)
+        raise CorruptError, "invalid raw quantization matrix" unless values.all?(&:positive?)
+
+        values.map { _1 * denominator }
+      end
+      private :read_raw_matrix
+
+      def self.read_parametric_matrix(reader, mode, table)
+        raise CorruptError, "invalid parametric quantization mode" unless TABLE_LENGTHS[table] == 3 * 64 || mode == 6
+
+        weights = case mode
+                  when 1 then identity_weights(read_values(reader, 3, 3, scale: 64))
+                  when 2 then dct2_weights(read_values(reader, 3, 6, scale: 64))
+                  when 3 then read_dct4_weights(reader)
+                  when 4 then dct4x8_weights(read_values(reader, 3, 1).flatten, read_dct_params(reader))
+                  when 5 then read_afv_weights(reader)
+                  when 6 then dct_weights(TABLE_WIDTHS[table] * 8, TABLE_HEIGHTS[table] * 8,
+                                          read_dct_params(reader))
+                  else raise CorruptError, "invalid parametric quantization mode"
+                  end
+        raise CorruptError, "invalid parametric quantization matrix" unless weights.all? { _1 >= 1e-8 && _1 < 1e8 }
+
+        weights.map { 1.0 / _1 }
+      end
+
+      def self.read_values(reader, channels, count, scale: 1)
+        Array.new(channels) do
+          Array.new(count) do
+            value = Bit::Field.f16(reader) * scale
+            raise CorruptError, "quantization weight is too small" if value.abs < 1e-8
+
+            value
+          end
+        end
+      end
+      private_class_method :read_values
+
+      def self.read_dct_params(reader)
+        count = reader.read(4) + 1
+        bands = Array.new(3) do
+          Array.new(count) { Bit::Field.f16(reader) }.tap do |values|
+            raise CorruptError, "distance band seed is too small" if values.first < 1e-8
+
+            values[0] *= 64.0
+          end
+        end
+        [count, bands]
+      end
+      private_class_method :read_dct_params
+
+      def self.identity_weights(values)
+        values.flat_map do |base, axis, diagonal|
+          Array.new(64, base).tap do |weights|
+            weights[1] = weights[8] = axis
+            weights[9] = diagonal
+          end
+        end
+      end
+      private_class_method :identity_weights
+
+      def self.dct2_weights(values)
+        values.flat_map do |channel|
+          Array.new(64).tap do |weights|
+            weights[0] = 1.0
+            weights[1] = weights[8] = channel[0]
+            weights[9] = channel[1]
+            2.times do |y|
+              2.times do |x|
+                weights[(y * 8) + x + 2] = weights[((y + 2) * 8) + x] = channel[2]
+                weights[((y + 2) * 8) + x + 2] = channel[3]
+              end
+            end
+            4.times do |y|
+              4.times do |x|
+                weights[(y * 8) + x + 4] = weights[((y + 4) * 8) + x] = channel[4]
+                weights[((y + 4) * 8) + x + 4] = channel[5]
+              end
+            end
+          end
+        end
+      end
+      private_class_method :dct2_weights
+
+      def self.dct4_weights(params, multipliers)
+        base = dct_weights(4, 4, params)
+        3.times.flat_map do |channel|
+          weights = Array.new(64) do |index|
+            x = index % 8
+            y = index / 8
+            base[(channel * 16) + ((y / 2) * 4) + (x / 2)]
+          end
+          weights[1] /= multipliers[channel][0]
+          weights[8] /= multipliers[channel][0]
+          weights[9] /= multipliers[channel][1]
+          weights
+        end
+      end
+      private_class_method :dct4_weights
+
+      def self.read_dct4_weights(reader)
+        multipliers = read_values(reader, 3, 2)
+        dct4_weights(read_dct_params(reader), multipliers)
+      end
+      private_class_method :read_dct4_weights
+
+      def self.dct4x8_weights(multipliers, params)
+        base = dct_weights(4, 8, params)
+        3.times.flat_map do |channel|
+          weights = Array.new(64) do |index|
+            x = index % 8
+            y = index / 8
+            base[(channel * 32) + ((y / 2) * 8) + x]
+          end
+          weights[8] /= multipliers[channel]
+          weights
+        end
+      end
+      private_class_method :dct4x8_weights
+
+      def self.read_afv_weights(reader)
+        special = Array.new(3) do
+          Array.new(9) { Bit::Field.f16(reader) }.tap do |values|
+            6.times { |index| values[index] *= 64.0 }
+          end
+        end
+        afv_weights(special, read_dct_params(reader), read_dct_params(reader))
+      end
+      private_class_method :read_afv_weights
+
+      def self.afv_weights(special, params4x8, params4x4)
+        frequencies = [0, 0, 0.8517778890324296, 5.37778436506804,
+                       0, 0, 4.734747904497923, 5.449245381693219,
+                       1.6598270267479331, 4, 7.275749096817861, 10.423227632456525,
+                       2.662932286148962, 7.630657783650829, 8.962388608184032, 12.97166202570235]
+        base4x8 = dct_weights(4, 8, params4x8)
+        base4x4 = dct_weights(4, 4, params4x4)
+        low = 0.8517778890324296
+        high = 12.97166202570235 - low + 1e-6
+        3.times.flat_map do |channel| # rubocop:disable Metrics/BlockLength
+          controls = [special[channel][5]]
+          3.times { |index| controls << (controls.last * multiplier(special[channel][index + 6])) }
+          raise CorruptError, "invalid AFV distance bands" unless controls.all? { _1 >= 1e-8 }
+
+          Array.new(64).tap do |weights|
+            weights[0] = 1.0
+            weights[8] = special[channel][0]
+            weights[1] = special[channel][1]
+            weights[16] = special[channel][2]
+            weights[2] = special[channel][3]
+            weights[18] = special[channel][4]
+            4.times do |y|
+              4.times do |x|
+                next if x < 2 && y < 2
+
+                weights[(2 * y * 8) + (2 * x)] = interpolate(frequencies[(y * 4) + x] - low, high, controls)
+              end
+            end
+            4.times do |y|
+              8.times do |x|
+                next if x.zero? && y.zero?
+
+                weights[(((2 * y) + 1) * 8) + x] = base4x8[(channel * 32) + (y * 8) + x]
+              end
+            end
+            4.times do |y|
+              4.times do |x|
+                next if x.zero? && y.zero?
+
+                weights[(2 * y * 8) + (2 * x) + 1] = base4x4[(channel * 16) + (y * 4) + x]
+              end
+            end
+          end
+        end
+      end
+      private_class_method :afv_weights
+
+      def self.dct_weights(rows, columns, params)
+        count, channels = params
+        channels.flat_map do |encoded|
+          bands = [encoded.first]
+          encoded.drop(1).each { bands << (bands.last * multiplier(_1)) }
+          scale = (count - 1) / (Math.sqrt(2.0) + 1e-6)
+          Array.new(rows * columns) do |index|
+            x = index % columns
+            y = index / columns
+            distance = Math.hypot(x * scale / (columns - 1), y * scale / (rows - 1))
+            count == 1 ? bands.first : interpolate(distance, Math.sqrt(2.0) + 1e-6, bands)
+          end
+        end
+      end
+      private_class_method :dct_weights
+
+      def self.interpolate(position, maximum, values)
+        scaled = position * (values.length - 1) / maximum
+        index = [scaled.to_i, values.length - 2].min
+        a = values[index]
+        a * ((values[index + 1] / a)**(scaled - index))
+      end
+      private_class_method :interpolate
+
+      def self.multiplier(value) = value.positive? ? 1.0 + value : 1.0 / (1.0 - value)
+      private_class_method :multiplier
+
+      def self.default_tables
+        @default_tables ||= begin
+          require "zlib"
+          bytes = Zlib::Inflate.inflate(File.binread(TABLE_PATH))
+          expected = TABLE_OFFSETS.last * 4
+          raise InternalError, "invalid default dequant table data" unless bytes.bytesize == expected
+
+          bytes.unpack("e*").freeze
+        end
+      end
+    end
+  end
+end

data/lib/jxl/vardct/hf_global.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module JXL
+  module VarDCT
+    ORDER_DISTRIBUTION = [Bit::Field.val(0x5F), Bit::Field.val(0x13),
+                          Bit::Field.val(0), Bit::Field.bits(13)].freeze
+    HFPass = Data.define(:orders, :entropy)
+    HFGlobal = Data.define(:histogram_count, :passes) do
+      def self.read(reader, frame, lf_global, lf_groups, metadata: nil)
+        group_dim = 128 << frame.group_size_shift
+        dc_groups = Num.ceil_div(frame.blocks_width, group_dim) * Num.ceil_div(frame.blocks_height, group_dim)
+        lf_global.dequant.read_matrices!(
+          reader, state: lf_global.modular_state, metadata:, stream_base: 1 + (3 * dc_groups)
+        )
+
+        group_count = Num.ceil_div(frame.encoded_width, group_dim) * Num.ceil_div(frame.encoded_height, group_dim)
+        histogram_count = 1 + reader.read((group_count - 1).bit_length)
+        used = lf_groups.flat_map(&:used_strategies).uniq
+        passes = Array.new(frame.passes.count) do
+          used_orders = Bit::Field.u32(reader, *ORDER_DISTRIBUTION)
+          orders = CoeffOrder.read(reader, used_orders, used)
+          contexts = histogram_count * lf_global.block_context_map.ac_context_count
+          entropy = Entropy::Decoder.read(reader, contexts, defer_state: true)
+          HFPass.new(orders:, entropy:)
+        end
+        new(histogram_count:, passes:)
+      end
+    end
+  end
+end

data/lib/jxl/vardct/lf_global.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module JXL
+  module VarDCT
+    LFGlobal = Data.define(:dequant, :quantizer, :block_context_map, :chroma_from_luma,
+                           :modular_state, :modular_group, :extra_channels, :noise, :patches, :splines) do
+      def self.read(reader, frame, metadata = nil, references: [])
+        patches = if frame.flags.anybits?(2)
+                    Features::Patches.read(reader, frame.encoded_width, frame.encoded_height,
+                                           metadata.extra_channels.length, references)
+                  end
+        splines = Features::Splines.read(reader, frame.encoded_width, frame.encoded_height) if frame.flags.anybits?(16)
+        noise = frame.flags.anybits?(1) ? Array.new(8) { reader.read(10) / 1024.0 } : nil
+        dequant = Dequant.read_dc(reader)
+        quantizer = Quantizer.read(reader)
+        block_context_map = BlockContextMap.read(reader)
+        chroma_from_luma = ChromaFromLuma.read_dc(reader)
+        modular_state = Modular::Stream.read_global_state(reader)
+        shapes = if metadata
+                   metadata.extra_channels.each_index.map do |index|
+                     upsampling = frame.extra_channel_upsampling[index]
+                     [Num.ceil_div(frame.width, upsampling), Num.ceil_div(frame.height, upsampling)]
+                   end
+                 else
+                   []
+                 end
+        shifts = frame.extra_channel_upsampling.first(shapes.length).map do |upsampling|
+          shift = upsampling.bit_length - frame.upsampling.bit_length
+          [shift, shift]
+        end
+        modular_group = unless shapes.empty?
+                          Modular::Decoder.read_grouped_stream(
+                            reader, shapes, state: modular_state, metadata:,
+                                            group_dim: 128 << frame.group_size_shift, shifts:
+                          )
+                        end
+        extra_channels = modular_group&.channels || []
+        new(dequant:, quantizer:, block_context_map:, chroma_from_luma:, modular_state:,
+            modular_group:, extra_channels:, noise:, patches:, splines:)
+      end
+    end
+  end
+end