jxl 1.0.0

data/lib/jxl/headers/bit_depth.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module JXL
+  module Headers
+    BitDepth = Data.define(:floating_point, :bits_per_sample, :exponent_bits) do
+      def self.read(reader)
+        floating_point = Bit::Field.read_bool(reader)
+        bits_per_sample = if floating_point
+                            Bit::Field.u32(reader, Bit::Field.val(32), Bit::Field.val(16),
+                                           Bit::Field.val(24), Bit::Field.bits_offset(6, 1))
+                          else
+                            Bit::Field.u32(reader, Bit::Field.val(8), Bit::Field.val(10),
+                                           Bit::Field.val(12), Bit::Field.bits_offset(6, 1))
+                          end
+        exponent_bits = floating_point ? reader.read(4) + 1 : 0
+        validate!(floating_point, bits_per_sample, exponent_bits)
+        new(floating_point:, bits_per_sample:, exponent_bits:)
+      end
+
+      def self.validate!(floating_point, bits, exponent)
+        if floating_point
+          mantissa = bits - exponent - 1
+          raise CorruptError, "invalid floating-point bit depth" unless exponent.between?(2,
+                                                                                          8) && mantissa.between?(2, 23)
+        elsif bits > 31
+          raise CorruptError, "invalid integer bit depth"
+        end
+      end
+      private_class_method :validate!
+    end
+  end
+end

data/lib/jxl/headers/colour_encoding.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module JXL
+  module Headers
+    ColourEncoding = Data.define(:want_icc, :colour_space, :white_point, :primaries,
+                                 :transfer_function, :gamma, :rendering_intent,
+                                 :white_point_xy, :primaries_xy)
+
+    class ColourEncoding
+      DEFAULT = { want_icc: false, colour_space: 0, white_point: 1, primaries: 1,
+                  transfer_function: 13, gamma: nil, rendering_intent: 1,
+                  white_point_xy: nil, primaries_xy: nil }.freeze
+      CUSTOM_XY = [Bit::Field.bits(19), Bit::Field.bits_offset(19, 524_288),
+                   Bit::Field.bits_offset(20, 1_048_576), Bit::Field.bits_offset(21, 2_097_152)].freeze
+      ENUM = [Bit::Field.val(0), Bit::Field.val(1), Bit::Field.bits_offset(4, 2),
+              Bit::Field.bits_offset(6, 18)].freeze
+
+      def self.read(reader)
+        return new(**DEFAULT) if Bit::Field.read_bool(reader)
+
+        want_icc = Bit::Field.read_bool(reader)
+        colour_space = read_enum(reader, [0, 1, 2, 3], "colour space")
+        raise CorruptError, "unknown colour space without ICC" if !want_icc && colour_space == 3
+
+        values = DEFAULT.merge(want_icc:, colour_space:)
+        unless want_icc
+          values[:white_point], values[:white_point_xy] = read_white_point(reader, colour_space)
+          values[:primaries], values[:primaries_xy] = read_primaries(reader, colour_space)
+          values[:transfer_function], values[:gamma] = read_transfer_function(reader, colour_space)
+          values[:rendering_intent] = read_enum(reader, [0, 1, 2, 3], "rendering intent")
+        end
+        new(**values)
+      end
+
+      def self.read_white_point(reader, colour_space)
+        return [1, nil] if colour_space == 2
+
+        value = read_enum(reader, [1, 2, 10, 11], "white point")
+        [value, value == 2 ? read_xy(reader) : nil]
+      end
+      private_class_method :read_white_point
+
+      def self.read_primaries(reader, colour_space)
+        return [1, nil] if [1, 2].include?(colour_space)
+
+        value = read_enum(reader, [1, 2, 9, 11], "primaries")
+        [value, value == 2 ? Array.new(3) { read_xy(reader) } : nil]
+      end
+      private_class_method :read_primaries
+
+      def self.read_xy(reader) = Array.new(2) { Num.unpack_signed(Bit::Field.u32(reader, *CUSTOM_XY)) / 1_000_000.0 }
+      private_class_method :read_xy
+
+      def self.read_transfer_function(reader, colour_space)
+        return [nil, 3_333_333] if colour_space == 2
+
+        have_gamma = Bit::Field.read_bool(reader)
+        if have_gamma
+          gamma = reader.read(24)
+          raise CorruptError, "invalid gamma" unless gamma.between?(1221, 10_000_000)
+
+          [nil, gamma]
+        else
+          value = read_enum(reader, [1, 2, 8, 13, 16, 17, 18], "transfer function")
+          raise CorruptError, "unknown transfer function without ICC" if value == 2
+
+          [value, nil]
+        end
+      end
+      private_class_method :read_transfer_function
+
+      def self.read_enum(reader, allowed, name)
+        value = Bit::Field.u32(reader, *ENUM)
+        raise CorruptError, "invalid #{name}" unless allowed.include?(value)
+
+        value
+      end
+      private_class_method :read_enum
+    end
+  end
+end

data/lib/jxl/headers/custom_transform.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module JXL
+  module Headers
+    module CustomTransform
+      WEIGHT_COUNTS = [15, 55, 210].freeze
+      DEFAULT_MATRIX = [11.031566901960783, -9.866943921568629, -0.16462299647058826,
+                        -3.254147380392157, 4.418770392156863, -0.16462299647058826,
+                        -3.6588512862745097, 2.7129230470588235, 1.9459282392156863].freeze
+      DEFAULT_BIASES = Array.new(3, -0.0037930732552754493).freeze
+      DEFAULT_QUANT_BIASES = [0.945349926692846, 0.9299455010825141, 0.9500648966626564, 0.145].freeze
+      Opsin = Data.define(:inverse_matrix, :biases, :quant_biases)
+      TransformData = Data.define(:opsin, :weights)
+
+      module_function
+
+      def read(reader, xyb_encoded:)
+        return defaults if Bit::Field.read_bool(reader)
+
+        opsin = xyb_encoded ? read_opsin(reader) : nil
+        mask = reader.read(3)
+        weights = WEIGHT_COUNTS.each_with_index.map do |count, index|
+          mask[index].zero? ? nil : Array.new(count) { Bit::Field.f16(reader) }
+        end
+        TransformData.new(opsin:, weights:)
+      end
+
+      def read_opsin(reader)
+        return default_opsin if Bit::Field.read_bool(reader)
+
+        Opsin.new(inverse_matrix: Array.new(9) { Bit::Field.f16(reader) },
+                  biases: Array.new(3) { Bit::Field.f16(reader) },
+                  quant_biases: Array.new(4) { Bit::Field.f16(reader) })
+      end
+      private_class_method :read_opsin
+
+      def defaults = TransformData.new(opsin: default_opsin, weights: Array.new(3))
+      private_class_method :defaults
+
+      def default_opsin
+        Opsin.new(inverse_matrix: DEFAULT_MATRIX, biases: DEFAULT_BIASES, quant_biases: DEFAULT_QUANT_BIASES)
+      end
+      private_class_method :default_opsin
+    end
+  end
+end

data/lib/jxl/headers/frame_header.rb

@@ -0,0 +1,251 @@
+# frozen_string_literal: true
+
+module JXL
+  module Headers
+    FRAME_CROP_DISTRIBUTION = [Bit::Field.bits(8), Bit::Field.bits_offset(11, 256),
+                               Bit::Field.bits_offset(14, 2304),
+                               Bit::Field.bits_offset(30, 18_688)].freeze
+    FRAME_UPSAMPLING_DISTRIBUTION = [1, 2, 4, 8].map { |value| Bit::Field.val(value) }.freeze
+
+    Passes = Data.define(:count, :shifts, :downsamples, :last_passes)
+    BlendInfo = Data.define(:mode, :alpha_channel, :clamp, :source)
+    LoopFilter = Data.define(:gaborish, :gaborish_weights, :epf_iterations, :epf_sharpness,
+                             :epf_channel_scale, :epf_zero_flush, :epf_quant_mul,
+                             :epf_sigma_scale, :epf_border_sad_mul, :epf_sigma_for_modular)
+    FrameHeader = Data.define(:type, :encoding, :flags, :colour_transform, :chroma_subsampling, :upsampling,
+                              :extra_channel_upsampling, :group_size_shift, :x_qm_scale, :b_qm_scale,
+                              :passes, :dc_level, :origin_x, :origin_y, :width, :height, :blend,
+                              :extra_channel_blends, :duration, :timecode, :last, :save_as_reference,
+                              :save_before_colour_transform, :name, :loop_filter) do
+      def encoded_width = Num.ceil_div(width, upsampling << (3 * dc_level))
+      def encoded_height = Num.ceil_div(height, upsampling << (3 * dc_level))
+      def blocks_width = Num.ceil_div(encoded_width, 8 << max_hshift) << max_hshift
+      def blocks_height = Num.ceil_div(encoded_height, 8 << max_vshift) << max_vshift
+      def max_hshift = chroma_subsampling.map(&:first).max
+      def max_vshift = chroma_subsampling.map(&:last).max
+
+      def self.read(reader, metadata:, image_width:, image_height:)
+        return defaults(metadata, image_width, image_height) if Bit::Field.read_bool(reader)
+
+        values = read_core(reader, metadata)
+        read_geometry(reader, values, image_width, image_height)
+        read_compositing(reader, values, metadata, image_width, image_height)
+        values[:name] = Bit::Field.string(reader)
+        values[:loop_filter] = read_loop_filter(reader, values[:encoding])
+        Bit::Field.skip_extensions(reader)
+        new(**values)
+      end
+
+      def self.read_core(reader, metadata)
+        type = reader.read(2)
+        encoding = Bit::Field.read_bool(reader) ? :modular : :vardct
+        flags = Bit::Field.u64(reader)
+        colour_transform = if metadata.xyb_encoded
+                             :xyb
+                           else
+                             (Bit::Field.read_bool(reader) ? :ycbcr : :none)
+                           end
+        chroma_subsampling = if colour_transform == :ycbcr && flags.nobits?(32)
+                               read_chroma_subsampling(reader)
+                             else
+                               Array.new(3) { [0, 0] }
+                             end
+        upsampling = flags.nobits?(32) ? Bit::Field.u32(reader, *FRAME_UPSAMPLING_DISTRIBUTION) : 1
+        extra_upsampling = flags.nobits?(32) ? read_extra_upsampling(reader, metadata, upsampling) : []
+        group_shift = encoding == :modular ? reader.read(2) : 1
+        x_qm = encoding == :vardct && colour_transform == :xyb ? reader.read(3) : 2
+        b_qm = encoding == :vardct && colour_transform == :xyb ? reader.read(3) : 2
+        passes = type == 2 ? default_passes : read_passes(reader)
+        dc_level = type == 1 ? Bit::Field.u32(reader, *[1, 2, 3, 4].map { |value| Bit::Field.val(value) }) : 0
+        { type:, encoding:, flags:, colour_transform:, chroma_subsampling:, upsampling:,
+          extra_channel_upsampling: extra_upsampling,
+          group_size_shift: group_shift, x_qm_scale: x_qm, b_qm_scale: b_qm, passes:, dc_level: }
+      end
+      private_class_method :read_core
+
+      def self.read_chroma_subsampling(reader)
+        raw_h = [0, 1, 1, 0]
+        raw_v = [0, 1, 0, 1]
+        modes = Array.new(3) { reader.read(2) }
+        max_h = modes.map { raw_h[_1] }.max
+        max_v = modes.map { raw_v[_1] }.max
+        modes.map { |mode| [max_h - raw_h[mode], max_v - raw_v[mode]] }
+      end
+      private_class_method :read_chroma_subsampling
+
+      def self.read_extra_upsampling(reader, metadata, colour_upsampling)
+        metadata.extra_channels.map do |channel|
+          value = Bit::Field.u32(reader, *FRAME_UPSAMPLING_DISTRIBUTION) << channel.dim_shift
+          raise CorruptError, "invalid extra-channel upsampling" unless value.between?(colour_upsampling, 8)
+
+          value
+        end
+      end
+      private_class_method :read_extra_upsampling
+
+      def self.read_passes(reader)
+        count = Bit::Field.u32(reader, Bit::Field.val(1), Bit::Field.val(2),
+                               Bit::Field.val(3), Bit::Field.bits_offset(3, 4))
+        return default_passes if count == 1
+
+        downsample_count = Bit::Field.u32(reader, Bit::Field.val(0), Bit::Field.val(1),
+                                          Bit::Field.val(2), Bit::Field.bits_offset(1, 3))
+        shifts = Array.new(count - 1) { reader.read(2) } << 0
+        raise CorruptError, "too many downsampling stages" if downsample_count > count
+
+        downsamples = Array.new(downsample_count) { Bit::Field.u32(reader, *FRAME_UPSAMPLING_DISTRIBUTION) }
+        last_passes = Array.new(downsample_count) do
+          Bit::Field.u32(reader, Bit::Field.val(0), Bit::Field.val(1), Bit::Field.val(2), Bit::Field.bits(3))
+        end
+        raise CorruptError, "invalid downsampling order" unless downsamples.each_cons(2).all? { |a, b| b < a }
+        unless last_passes.each_cons(2).all? { |a, b| b > a } && last_passes.all? { |pass| pass < count }
+          raise CorruptError, "invalid last-pass order"
+        end
+
+        Passes.new(count:, shifts:, downsamples:, last_passes:)
+      end
+      private_class_method :read_passes
+
+      def self.default_passes = Passes.new(count: 1, shifts: [0], downsamples: [], last_passes: [])
+      private_class_method :default_passes
+
+      def self.read_geometry(reader, values, image_width, image_height)
+        custom = values[:type] != 1 && Bit::Field.read_bool(reader)
+        values[:origin_x] = values[:origin_y] = 0
+        values[:width] = image_width
+        values[:height] = image_height
+        return unless custom
+
+        if [0, 3].include?(values[:type])
+          values[:origin_x] = Num.unpack_signed(Bit::Field.u32(reader, *FRAME_CROP_DISTRIBUTION))
+          values[:origin_y] = Num.unpack_signed(Bit::Field.u32(reader, *FRAME_CROP_DISTRIBUTION))
+        end
+        values[:width] = Bit::Field.u32(reader, *FRAME_CROP_DISTRIBUTION)
+        values[:height] = Bit::Field.u32(reader, *FRAME_CROP_DISTRIBUTION)
+        raise CorruptError, "empty frame" unless values[:width].positive? && values[:height].positive?
+      end
+      private_class_method :read_geometry
+
+      def self.read_compositing(reader, values, metadata, image_width, image_height)
+        regular = [0, 3].include?(values[:type])
+        partial = values[:origin_x].positive? || values[:origin_y].positive? ||
+                  values[:origin_x] + values[:width] < image_width ||
+                  values[:origin_y] + values[:height] < image_height
+        values[:blend] = regular ? read_blend(reader, metadata.extra_channels.length, partial) : default_blend
+        values[:extra_channel_blends] = if regular
+                                          metadata.extra_channels.map do
+                                            read_blend(reader, metadata.extra_channels.length, partial)
+                                          end
+                                        else
+                                          []
+                                        end
+        values[:duration] = regular && metadata.animation ? read_duration(reader) : 0
+        values[:timecode] = regular && metadata.animation&.have_timecodes ? reader.read(32) : 0
+        values[:last] = regular ? Bit::Field.read_bool(reader) : false
+        values[:save_as_reference] = values[:type] != 1 && !values[:last] ? reader.read(2) : 0
+        can_reference = !values[:last] && values[:type] != 1 &&
+                        (values[:duration].zero? || !values[:save_as_reference].zero?)
+        may_choose_reference = can_reference && values[:blend].mode.zero? && !partial && regular
+        values[:save_before_colour_transform] = if may_choose_reference || values[:type] == 2
+                                                  Bit::Field.read_bool(reader)
+                                                else
+                                                  values[:type] == 1
+                                                end
+      end
+      private_class_method :read_compositing
+
+      def self.read_duration(reader)
+        Bit::Field.u32(reader, Bit::Field.val(0), Bit::Field.val(1), Bit::Field.bits(8), Bit::Field.bits(32))
+      end
+      private_class_method :read_duration
+
+      def self.read_blend(reader, extra_channels, partial)
+        mode = Bit::Field.u32(reader, Bit::Field.val(0), Bit::Field.val(1),
+                              Bit::Field.val(2), Bit::Field.bits_offset(2, 3))
+        raise CorruptError, "invalid blend mode" if mode > 4
+
+        uses_alpha = extra_channels.positive? && [2, 3].include?(mode)
+        alpha = if uses_alpha
+                  Bit::Field.u32(reader, Bit::Field.val(0), Bit::Field.val(1),
+                                 Bit::Field.val(2), Bit::Field.bits_offset(3, 3))
+                else
+                  0
+                end
+        raise CorruptError, "invalid blend alpha channel" if alpha >= extra_channels && uses_alpha
+
+        clamp = (uses_alpha || mode == 4) && Bit::Field.read_bool(reader)
+        source = mode != 0 || partial ? reader.read(2) : 0
+        BlendInfo.new(mode:, alpha_channel: alpha, clamp:, source:)
+      end
+      private_class_method :read_blend
+
+      def self.default_blend = BlendInfo.new(mode: 0, alpha_channel: 0, clamp: false, source: 0)
+      private_class_method :default_blend
+
+      def self.read_loop_filter(reader, encoding)
+        return default_loop_filter if Bit::Field.read_bool(reader)
+
+        gaborish = Bit::Field.read_bool(reader)
+        weights = if gaborish && Bit::Field.read_bool(reader)
+                    Array.new(3) { [Bit::Field.f16(reader), Bit::Field.f16(reader)] }
+                  else
+                    default_gaborish_weights
+                  end
+        epf = reader.read(2)
+        options = epf.positive? ? read_epf_options(reader, encoding) : default_epf_options
+        Bit::Field.skip_extensions(reader)
+        LoopFilter.new(gaborish:, gaborish_weights: weights, epf_iterations: epf, **options)
+      end
+      private_class_method :read_loop_filter
+
+      def self.read_epf_options(reader, encoding)
+        values = default_epf_options
+        if encoding == :vardct && Bit::Field.read_bool(reader)
+          values[:epf_sharpness] = Array.new(8) { Bit::Field.f16(reader) }
+        end
+        if Bit::Field.read_bool(reader)
+          values[:epf_channel_scale] = Array.new(3) { Bit::Field.f16(reader) }
+          values[:epf_zero_flush] = Array.new(2) { Bit::Field.f16(reader) }
+        end
+        if Bit::Field.read_bool(reader)
+          values[:epf_quant_mul] = Bit::Field.f16(reader) if encoding == :vardct
+          values[:epf_sigma_scale] = Array.new(2) { Bit::Field.f16(reader) }
+          values[:epf_border_sad_mul] = Bit::Field.f16(reader)
+        end
+        values[:epf_sigma_for_modular] = Bit::Field.f16(reader) if encoding == :modular
+        values
+      end
+      private_class_method :read_epf_options
+
+      def self.default_gaborish_weights
+        Array.new(3) { [1.1 * 0.104699568, 1.1 * 0.055680538] }
+      end
+      private_class_method :default_gaborish_weights
+
+      def self.default_epf_options
+        { epf_sharpness: Array.new(8) { |index| index / 7.0 }, epf_channel_scale: [40.0, 5.0, 3.5],
+          epf_zero_flush: [0.45, 0.6], epf_quant_mul: 0.46, epf_sigma_scale: [0.9, 6.5],
+          epf_border_sad_mul: 2.0 / 3, epf_sigma_for_modular: 1.0 }
+      end
+      private_class_method :default_epf_options
+
+      def self.default_loop_filter
+        LoopFilter.new(gaborish: true, gaborish_weights: default_gaborish_weights, epf_iterations: 2,
+                       **default_epf_options)
+      end
+      private_class_method :default_loop_filter
+
+      def self.defaults(metadata, width, height)
+        new(type: 0, encoding: :vardct, flags: 0, colour_transform: metadata.xyb_encoded ? :xyb : :none,
+            chroma_subsampling: Array.new(3) { [0, 0] },
+            upsampling: 1, extra_channel_upsampling: Array.new(metadata.extra_channels.length, 1),
+            group_size_shift: 1, x_qm_scale: 3, b_qm_scale: 2, passes: default_passes,
+            dc_level: 0, origin_x: 0, origin_y: 0, width:, height:, blend: default_blend,
+            extra_channel_blends: Array.new(metadata.extra_channels.length) { default_blend }, duration: 0,
+            timecode: 0, last: true, save_as_reference: 0, save_before_colour_transform: false,
+            name: "", loop_filter: default_loop_filter)
+      end
+      private_class_method :defaults
+    end
+  end
+end

data/lib/jxl/headers/image_metadata.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module JXL
+  module Headers
+    ExtraChannel = Data.define(:type, :bit_depth, :dim_shift, :name, :alpha_associated, :spot_colour, :cfa_channel)
+    Animation = Data.define(:ticks_numerator, :ticks_denominator, :loops, :have_timecodes)
+    ToneMapping = Data.define(:intensity_target, :min_nits, :relative_to_max_display, :linear_below)
+    ImageMetadata = Data.define(:orientation, :intrinsic_size, :preview_size, :animation, :bit_depth,
+                                :modular_16_bit_buffer, :extra_channels, :xyb_encoded, :colour_encoding,
+                                :tone_mapping, :extensions) do
+      def self.read(reader, max_pixels: 100_000_000)
+        return defaults if Bit::Field.read_bool(reader)
+
+        extra_fields = Bit::Field.read_bool(reader)
+        optional = extra_fields ? read_optional_fields(reader, max_pixels) : {}
+        bit_depth = BitDepth.read(reader)
+        modular_16_bit_buffer = Bit::Field.read_bool(reader)
+        count = Bit::Field.u32(reader, Bit::Field.val(0), Bit::Field.val(1),
+                               Bit::Field.bits_offset(4, 2), Bit::Field.bits_offset(12, 1))
+        raise ResourceLimitError, "too many extra channels" if count > 256
+
+        extra_channels = Array.new(count) { read_extra_channel(reader) }
+        xyb_encoded = Bit::Field.read_bool(reader)
+        colour_encoding = ColourEncoding.read(reader)
+        tone_mapping = extra_fields ? read_tone_mapping(reader) : default_tone_mapping
+        Bit::Field.skip_extensions(reader)
+        new(orientation: optional.fetch(:orientation, 1), intrinsic_size: optional[:intrinsic_size],
+            preview_size: optional[:preview_size], animation: optional[:animation], bit_depth:,
+            modular_16_bit_buffer:, extra_channels:, xyb_encoded:, colour_encoding:, tone_mapping:, extensions: 0)
+      end
+
+      def self.defaults
+        new(orientation: 1, intrinsic_size: nil, preview_size: nil, animation: nil,
+            bit_depth: BitDepth.new(floating_point: false, bits_per_sample: 8, exponent_bits: 0),
+            modular_16_bit_buffer: true, extra_channels: [], xyb_encoded: true,
+            colour_encoding: ColourEncoding.new(**ColourEncoding::DEFAULT),
+            tone_mapping: default_tone_mapping, extensions: 0)
+      end
+
+      def self.read_optional_fields(reader, max_pixels)
+        values = { orientation: reader.read(3) + 1 }
+        values[:intrinsic_size] = SizeHeader.read(reader, max_pixels:) if Bit::Field.read_bool(reader)
+        values[:preview_size] = read_preview_size(reader) if Bit::Field.read_bool(reader)
+        values[:animation] = read_animation(reader) if Bit::Field.read_bool(reader)
+        values
+      end
+      private_class_method :read_optional_fields
+
+      def self.read_preview_size(reader)
+        div8 = Bit::Field.read_bool(reader)
+        if div8
+          distributions = [Bit::Field.val(16), Bit::Field.val(32), Bit::Field.bits_offset(5, 1),
+                           Bit::Field.bits_offset(9, 33)]
+          height = Bit::Field.u32(reader, *distributions) * 8
+        else
+          distributions = [Bit::Field.bits_offset(6, 1), Bit::Field.bits_offset(8, 65),
+                           Bit::Field.bits_offset(10, 321), Bit::Field.bits_offset(12, 1345)]
+          height = Bit::Field.u32(reader, *distributions)
+        end
+        ratio = reader.read(3)
+        width = if ratio.zero?
+                  Bit::Field.u32(reader, *distributions) * (div8 ? 8 : 1)
+                else
+                  ratio_width(height, ratio)
+                end
+        SizeHeader.new(width:, height:)
+      end
+      private_class_method :read_preview_size
+
+      def self.ratio_width(height, ratio)
+        numerator, denominator = SizeHeader::RATIOS.fetch(ratio - 1)
+        height * numerator / denominator
+      end
+      private_class_method :ratio_width
+
+      def self.read_animation(reader)
+        numerator = Bit::Field.u32(reader, Bit::Field.val(100), Bit::Field.val(1000),
+                                   Bit::Field.bits_offset(10, 1), Bit::Field.bits_offset(30, 1))
+        denominator = Bit::Field.u32(reader, Bit::Field.val(1), Bit::Field.val(1001),
+                                     Bit::Field.bits_offset(8, 1), Bit::Field.bits_offset(10, 1))
+        loops = Bit::Field.u32(reader, Bit::Field.val(0), Bit::Field.bits(3),
+                               Bit::Field.bits(16), Bit::Field.bits(32))
+        Animation.new(ticks_numerator: numerator, ticks_denominator: denominator,
+                      loops:, have_timecodes: Bit::Field.read_bool(reader))
+      end
+      private_class_method :read_animation
+
+      def self.read_extra_channel(reader)
+        return default_extra_channel if Bit::Field.read_bool(reader)
+
+        type = Bit::Field.enum(reader)
+        bit_depth = BitDepth.read(reader)
+        dim_shift = Bit::Field.u32(reader, Bit::Field.val(0), Bit::Field.val(3),
+                                   Bit::Field.val(4), Bit::Field.bits_offset(3, 1))
+        raise CorruptError, "extra-channel shift too large" if (1 << dim_shift) > 8
+
+        name = Bit::Field.string(reader)
+        alpha_associated = type.zero? ? Bit::Field.read_bool(reader) : false
+        spot_colour = type == 2 ? Array.new(4) { Bit::Field.f16(reader) } : nil
+        cfa_channel = if type == 5
+                        Bit::Field.u32(reader, Bit::Field.val(1), Bit::Field.bits(2),
+                                       Bit::Field.bits_offset(4, 3), Bit::Field.bits_offset(8, 19))
+                      end
+        ExtraChannel.new(type:, bit_depth:, dim_shift:, name:, alpha_associated:, spot_colour:, cfa_channel:)
+      end
+      private_class_method :read_extra_channel
+
+      def self.default_extra_channel
+        ExtraChannel.new(type: 0, bit_depth: BitDepth.new(floating_point: false, bits_per_sample: 8, exponent_bits: 0),
+                         dim_shift: 0, name: "", alpha_associated: false, spot_colour: nil, cfa_channel: nil)
+      end
+      private_class_method :default_extra_channel
+
+      def self.read_tone_mapping(reader)
+        return default_tone_mapping if Bit::Field.read_bool(reader)
+
+        ToneMapping.new(intensity_target: Bit::Field.f16(reader), min_nits: Bit::Field.f16(reader),
+                        relative_to_max_display: Bit::Field.read_bool(reader), linear_below: Bit::Field.f16(reader))
+      end
+      private_class_method :read_tone_mapping
+
+      def self.default_tone_mapping
+        ToneMapping.new(intensity_target: 255.0, min_nits: 0.0, relative_to_max_display: false, linear_below: 0.0)
+      end
+      private_class_method :default_tone_mapping
+    end
+  end
+end

data/lib/jxl/headers/size_header.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module JXL
+  module Headers
+    SizeHeader = Data.define(:width, :height)
+
+    class SizeHeader
+      RATIOS = [[1, 1], [12, 10], [4, 3], [3, 2], [16, 9], [5, 4], [2, 1]].freeze
+      DIMENSION = [Bit::Field.bits_offset(9, 1), Bit::Field.bits_offset(13, 1),
+                   Bit::Field.bits_offset(18, 1), Bit::Field.bits_offset(30, 1)].freeze
+
+      def self.read(reader, max_pixels: 100_000_000)
+        small = Bit::Field.read_bool(reader)
+        height = small ? (reader.read(5) + 1) * 8 : Bit::Field.u32(reader, *DIMENSION)
+        ratio = reader.read(3)
+        width = if ratio.zero?
+                  small ? (reader.read(5) + 1) * 8 : Bit::Field.u32(reader, *DIMENSION)
+                else
+                  numerator, denominator = RATIOS.fetch(ratio - 1)
+                  height * numerator / denominator
+                end
+        raise CorruptError, "empty JPEG XL image" unless width.positive? && height.positive?
+        raise ResourceLimitError, "image exceeds pixel limit" if width * height > max_pixels
+
+        new(width:, height:)
+      end
+    end
+  end
+end

data/lib/jxl/image.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module JXL
+  class Frame
+    attr_reader :planes, :duration, :timecode, :name, :blend_info
+
+    def initialize(planes:, duration:, timecode:, name:, blend_info:)
+      @planes = planes
+      @duration = duration
+      @timecode = timecode
+      @name = name
+      @blend_info = blend_info
+    end
+  end
+
+  class Image
+    attr_reader :width, :height, :channels, :metadata, :frames, :icc_profile
+
+    def initialize(width:, height:, channels:, metadata:, frames: [], icc_profile: nil) # rubocop:disable Metrics/ParameterLists
+      @width = width
+      @height = height
+      @channels = channels
+      @metadata = metadata
+      @frames = frames
+      @icc_profile = icc_profile
+    end
+
+    def with(**changes)
+      self.class.new(width: changes.fetch(:width, width), height: changes.fetch(:height, height),
+                     channels: changes.fetch(:channels, channels), metadata: changes.fetch(:metadata, metadata),
+                     frames: changes.fetch(:frames, frames), icc_profile: changes.fetch(:icc_profile, icc_profile))
+    end
+
+    def num_color_channels = channels.length - metadata.extra_channels.length
+    def extra_channels = channels.drop(num_color_channels)
+    def color_encoding = metadata.colour_encoding
+
+    # Returns interleaved RGBA pixels with 8-bit unsigned samples.
+    def to_rgba8 = interleaved_rgba.map { |value| (Num.clamp(value, 0.0, 1.0) * 255).round }.pack("C*")
+
+    # Returns little-endian interleaved RGBA pixels with 16-bit unsigned samples.
+    def to_rgba16
+      interleaved_rgba.map { |value| (Num.clamp(value, 0.0, 1.0) * 65_535).round }.pack("v*")
+    end
+
+    # Returns little-endian interleaved RGBA pixels with binary32 samples.
+    def to_float = interleaved_rgba.pack("e*")
+
+    private
+
+    def interleaved_rgba
+      colour = num_color_channels == 1 ? [channels[0]] * 3 : channels.first(3)
+      alpha_index = metadata.extra_channels.index { _1.type.zero? }
+      alpha = extra_channels[alpha_index] if alpha_index
+      [].tap do |values|
+        (width * height).times do |pixel|
+          colour.each { |plane| values << plane.data[pixel] }
+          values << (alpha ? alpha.data[pixel] : 1.0)
+        end
+      end
+    end
+  end
+end