jxl 1.0.0

data/lib/jxl/vardct/reconstructor.rb

@@ -0,0 +1,294 @@
+# frozen_string_literal: true
+
+module JXL
+  module VarDCT
+    module Reconstructor
+      QUANT_BIASES = [0.945349926692846, 0.9299455010825141, 0.9500648966626564, 0.145].freeze
+      AFV_BASIS_PATH = File.join(__dir__, "afv_basis.bin")
+
+      module_function
+
+      def reconstruct(frame, global, lf_group, pass_group, quant_biases: QUANT_BIASES)
+        width = frame.blocks_width * 8
+        height = frame.blocks_height * 8
+        output = frame.chroma_subsampling.map { |hshift, vshift| Plane.new(width >> hshift, height >> vshift) }
+        pass_group.blocks.each do |block|
+          pixels = reconstruct_block(frame, global, lf_group, block, quant_biases)
+          pixels.each_with_index do |channel, c|
+            hshift, vshift = frame.chroma_subsampling[c]
+            next unless block.x.nobits?((1 << hshift) - 1) && block.y.nobits?((1 << vshift) - 1)
+
+            blit!(channel, output[c], (block.x >> hshift) * 8, (block.y >> vshift) * 8)
+          end
+        end
+        output.each_with_index.map do |plane, channel|
+          hshift, vshift = frame.chroma_subsampling[channel]
+          crop(plane, Num.ceil_div(frame.encoded_width, 1 << hshift),
+               Num.ceil_div(frame.encoded_height, 1 << vshift))
+        end
+      end
+
+      def reconstruct_block(frame, global, lf_group, block, quant_biases)
+        coefficients = dequantize(frame, global, lf_group, block, quant_biases)
+        coefficients.each.map do |canonical|
+          plane_from(transform(canonical, block.strategy), block.strategy.width, block.strategy.height)
+        end
+      end
+      private_class_method :reconstruct_block
+
+      def transform(coefficients, strategy)
+        return identity(coefficients) if strategy.id == 1
+        return dct2x2(coefficients) if strategy.id == 2
+        return dct4x4(coefficients) if strategy.id == 3
+        return dct4x8(coefficients, vertical: true) if strategy.id == 12
+        return dct4x8(coefficients, vertical: false) if strategy.id == 13
+        return afv(coefficients, strategy.id - 14) if strategy.id.between?(14, 17)
+
+        physical = from_canonical(coefficients, strategy.width, strategy.height)
+        JXL::DCT.idct2d(physical, strategy.width, strategy.height)
+      end
+      private_class_method :transform
+
+      def identity(coefficients)
+        output = Array.new(64, 0.0)
+        dcs = hadamard4(coefficients[0], coefficients[1], coefficients[8], coefficients[9])
+        2.times do |y|
+          2.times do |x|
+            dc = dcs[(y * 2) + x]
+            residuals = Array.new(4) do |iy|
+              Array.new(4) { |ix| coefficients[((y + (iy * 2)) * 8) + x + (ix * 2)] }
+            end
+            center = dc - ((residuals.flatten.sum - residuals[0][0]) / 16.0)
+            4.times do |iy|
+              4.times { |ix| output[((((y * 4) + iy) * 8) + (x * 4)) + ix] = residuals[iy][ix] + center }
+            end
+            output[(((((y * 4) + 1) * 8) + (x * 4)) + 1)] = center
+            output[(y * 4 * 8) + (x * 4)] = coefficients[((y + 2) * 8) + x + 2] + center
+          end
+        end
+        output
+      end
+      private_class_method :identity
+
+      def dct2x2(coefficients)
+        values = coefficients.dup
+        [2, 4, 8].each do |size|
+          half = size / 2
+          output = values.dup
+          half.times do |y|
+            half.times do |x|
+              transformed = hadamard4(values[(y * 8) + x], values[(y * 8) + half + x],
+                                      values[((y + half) * 8) + x], values[((y + half) * 8) + half + x])
+              transformed.each_with_index do |value, index|
+                output[(((((y * 2) + (index / 2)) * 8) + (x * 2)) + (index % 2))] = value
+              end
+            end
+          end
+          values = output
+        end
+        values
+      end
+      private_class_method :dct2x2
+
+      def dct4x4(coefficients)
+        output = Array.new(64, 0.0)
+        dcs = hadamard4(coefficients[0], coefficients[1], coefficients[8], coefficients[9])
+        2.times do |y|
+          2.times do |x|
+            block = Array.new(16, 0.0)
+            block[0] = dcs[(y * 2) + x]
+            4.times do |iy|
+              4.times do |ix|
+                next if ix.zero? && iy.zero?
+
+                block[(iy * 4) + ix] = coefficients[((y + (iy * 2)) * 8) + x + (ix * 2)]
+              end
+            end
+            blit_values!(JXL::DCT.idct2d(from_canonical(block, 4, 4), 4, 4),
+                         output, 4, 4, 8, x * 4, y * 4)
+          end
+        end
+        output
+      end
+      private_class_method :dct4x4
+
+      def dct4x8(coefficients, vertical:)
+        output = Array.new(64, 0.0)
+        dcs = [coefficients[0] + coefficients[8], coefficients[0] - coefficients[8]]
+        2.times do |part|
+          block = Array.new(32, 0.0)
+          block[0] = dcs[part]
+          4.times do |iy|
+            8.times do |ix|
+              next if ix.zero? && iy.zero?
+
+              block[(iy * 8) + ix] = coefficients[((part + (iy * 2)) * 8) + ix]
+            end
+          end
+          pixels = JXL::DCT.idct2d(block, 8, 4)
+          if vertical
+            blit_values!(pixels, output, 8, 4, 8, 0, part * 4)
+          else
+            transposed = Array.new(32) { |index| pixels[((index % 4) * 8) + (index / 4)] }
+            blit_values!(transposed, output, 4, 8, 8, part * 4, 0)
+          end
+        end
+        output
+      end
+      private_class_method :dct4x8
+
+      def afv(coefficients, kind)
+        output = Array.new(64, 0.0)
+        corner_x = kind & 1
+        corner_y = kind / 2
+        dcs = [(coefficients[0] + coefficients[8] + coefficients[1]) * 4.0,
+               coefficients[0] + coefficients[8] - coefficients[1], coefficients[0] - coefficients[8]]
+        corner_coefficients = Array.new(16) do |index|
+          index.zero? ? dcs[0] : coefficients[((index / 4) * 16) + ((index % 4) * 2)]
+        end
+        corner = Array.new(16) do |pixel|
+          16.times.sum { |coefficient| corner_coefficients[coefficient] * afv_basis[(coefficient * 16) + pixel] }
+        end
+        4.times do |y|
+          4.times do |x|
+            source_x = corner_x == 1 ? 3 - x : x
+            source_y = corner_y == 1 ? 3 - y : y
+            output[((y + (corner_y * 4)) * 8) + (corner_x * 4) + x] = corner[(source_y * 4) + source_x]
+          end
+        end
+
+        side = Array.new(16, 0.0)
+        side[0] = dcs[1]
+        4.times do |y|
+          4.times do |x|
+            side[(y * 4) + x] = coefficients[(y * 16) + (x * 2) + 1] unless x.zero? && y.zero?
+          end
+        end
+        blit_values!(JXL::DCT.idct2d(from_canonical(side, 4, 4), 4, 4),
+                     output, 4, 4, 8, corner_x == 1 ? 0 : 4, corner_y * 4)
+
+        opposite = Array.new(32, 0.0)
+        opposite[0] = dcs[2]
+        4.times do |y|
+          8.times do |x|
+            opposite[(y * 8) + x] = coefficients[((1 + (y * 2)) * 8) + x] unless x.zero? && y.zero?
+          end
+        end
+        blit_values!(JXL::DCT.idct2d(opposite, 8, 4), output, 8, 4, 8, 0, corner_y == 1 ? 0 : 4)
+        output
+      end
+      private_class_method :afv
+
+      def afv_basis = @afv_basis ||= File.binread(AFV_BASIS_PATH).unpack("e*").freeze
+      private_class_method :afv_basis
+
+      def hadamard4(a, b, c, d) = [a + b + c + d, a + b - c - d, a - b + c - d, a - b - c + d]
+      private_class_method :hadamard4
+
+      def blit_values!(source, target, width, height, stride, x, y)
+        height.times { |row| target[((y + row) * stride) + x, width] = source[row * width, width] }
+      end
+      private_class_method :blit_values!
+
+      def dequantize(frame, global, lf_group, block, quant_biases)
+        strategy = block.strategy
+        scale = global.quantizer.inverse_ac(lf_group.quant_field[block.x, block.y])
+        channel_scales = [1.25**(2 - frame.x_qm_scale), 1.0, 1.25**(2 - frame.b_qm_scale)]
+        values = block.coefficients.each_with_index.map do |quantized, channel|
+          matrix = global.dequant.matrix(strategy, channel)
+          quantized.each_with_index.map do |value, index|
+            adjust_bias(value, channel, quant_biases) * matrix[index] * scale * channel_scales[channel]
+          end
+        end
+        if frame.max_hshift.zero? && frame.max_vshift.zero?
+          add_ac_correlation!(values, global.chroma_from_luma, lf_group, block)
+        end
+        3.times do |channel|
+          hshift, vshift = frame.chroma_subsampling[channel]
+          add_dc!(values[channel], lf_group.dc[channel], block, hshift, vshift)
+        end
+        values
+      end
+      private_class_method :dequantize
+
+      def adjust_bias(value, channel, biases)
+        return 0.0 if value.zero?
+        return value.negative? ? -biases[channel] : biases[channel] if value.abs == 1
+
+        value - (biases[3] / value)
+      end
+      private_class_method :adjust_bias
+
+      def add_ac_correlation!(values, correlation, lf_group, block)
+        tile_x = block.x / 8
+        tile_y = block.y / 8
+        x_factor = correlation.x_ratio(lf_group.ytox_map[tile_x, tile_y])
+        b_factor = correlation.b_ratio(lf_group.ytob_map[tile_x, tile_y])
+        values[1].length.times do |index|
+          values[0][index] += values[1][index] * x_factor
+          values[2][index] += values[1][index] * b_factor
+        end
+      end
+      private_class_method :add_ac_correlation!
+
+      def add_dc!(coefficients, dc, block, hshift = 0, vshift = 0)
+        strategy = block.strategy
+        block_x = block.x >> hshift
+        block_y = block.y >> vshift
+        if strategy.blocks_x == 1 && strategy.blocks_y == 1
+          coefficients[0] = dc[block_x, block_y]
+          return
+        end
+
+        samples = Array.new(strategy.blocks_x * strategy.blocks_y) do |index|
+          dc[block_x + (index % strategy.blocks_x), block_y + (index / strategy.blocks_x)]
+        end
+        low = JXL::DCT.dct2d(samples, strategy.blocks_x, strategy.blocks_y)
+        strategy.blocks_y.times do |fy|
+          strategy.blocks_x.times do |fx|
+            value = low[(fy * strategy.blocks_x) + fx]
+            value *= JXL::DCT.resample_scale(strategy.blocks_x, strategy.width, fx)
+            value *= JXL::DCT.resample_scale(strategy.blocks_y, strategy.height, fy)
+            set_canonical!(coefficients, strategy.width, strategy.height, fx, fy, value)
+          end
+        end
+      end
+      private_class_method :add_dc!
+
+      def set_canonical!(values, width, height, x, y, value)
+        values[width > height ? (y * width) + x : (x * height) + y] = value
+      end
+      private_class_method :set_canonical!
+
+      def from_canonical(values, width, height)
+        return values if width > height
+
+        Array.new(values.length) do |index|
+          x = index % width
+          y = index / width
+          values[(x * height) + y]
+        end
+      end
+      private_class_method :from_canonical
+
+      def plane_from(values, width, height)
+        Plane.new(width, height).tap { _1.data.replace(values) }
+      end
+      private_class_method :plane_from
+
+      def blit!(source, target, x, y)
+        source.height.times do |row|
+          target.data[((y + row) * target.width) + x, source.width] = source.data[row * source.width, source.width]
+        end
+      end
+      private_class_method :blit!
+
+      def crop(source, width, height)
+        target = Plane.new(width, height)
+        height.times { |y| target.data[y * width, width] = source.data[y * source.width, width] }
+        target
+      end
+      private_class_method :crop
+    end
+  end
+end

data/lib/jxl/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module JXL
+  VERSION = "1.0.0"
+end

data/lib/jxl.rb

@@ -0,0 +1,216 @@
+# frozen_string_literal: true
+
+require_relative "jxl/version"
+require_relative "jxl/errors"
+require_relative "jxl/num"
+require_relative "jxl/plane"
+require_relative "jxl/image"
+require_relative "jxl/trace"
+require_relative "jxl/io/npy"
+require_relative "jxl/io/ppm"
+require_relative "jxl/io/pam"
+require_relative "jxl/io/pfm"
+require_relative "jxl/io/pgx"
+require_relative "jxl/io/png"
+require_relative "jxl/dct"
+require_relative "jxl/container/signature"
+require_relative "jxl/container/box"
+require_relative "jxl/container/parser"
+require_relative "jxl/bit/reader"
+require_relative "jxl/bit/writer"
+require_relative "jxl/bit/field"
+require_relative "jxl/entropy/hybrid_uint"
+require_relative "jxl/entropy/prefix_code"
+require_relative "jxl/entropy/encoder"
+require_relative "jxl/entropy/ans_distribution"
+require_relative "jxl/entropy/decoder"
+require_relative "jxl/entropy/icc_stream"
+require_relative "jxl/entropy/permutation"
+require_relative "jxl/vardct/ac_strategy"
+require_relative "jxl/vardct/dequant"
+require_relative "jxl/vardct/quantizer"
+require_relative "jxl/vardct/block_context_map"
+require_relative "jxl/vardct/chroma_from_luma"
+require_relative "jxl/modular/ma_tree"
+require_relative "jxl/modular/predictor"
+require_relative "jxl/modular/weighted"
+require_relative "jxl/modular/group_header"
+require_relative "jxl/modular/transform"
+require_relative "jxl/modular/decoder"
+require_relative "jxl/modular/stream"
+require_relative "jxl/vardct/lf_global"
+require_relative "jxl/vardct/lf_group"
+require_relative "jxl/vardct/coeff_order"
+require_relative "jxl/vardct/hf_global"
+require_relative "jxl/vardct/pass_group"
+require_relative "jxl/vardct/reconstructor"
+require_relative "jxl/color/opsin"
+require_relative "jxl/color/transfer"
+require_relative "jxl/color/ycbcr"
+require_relative "jxl/color/icc_profile"
+require_relative "jxl/color/gamut"
+require_relative "jxl/filter/gaborish"
+require_relative "jxl/filter/epf"
+require_relative "jxl/features/upsampling"
+require_relative "jxl/features/noise"
+require_relative "jxl/features/patches"
+require_relative "jxl/features/splines"
+require_relative "jxl/features/spot_colour"
+require_relative "jxl/render/blender"
+require_relative "jxl/render/orientation"
+require_relative "jxl/vardct/decoder"
+require_relative "jxl/headers/size_header"
+require_relative "jxl/headers/bit_depth"
+require_relative "jxl/headers/colour_encoding"
+require_relative "jxl/headers/image_metadata"
+require_relative "jxl/headers/custom_transform"
+require_relative "jxl/headers/frame_header"
+require_relative "jxl/frame/toc"
+require_relative "jxl/basic_info"
+require_relative "jxl/codestream/reader"
+require_relative "jxl/encoder"
+require_relative "jxl/decoder"
+
+module JXL
+  module_function
+
+  # Encodes an image as a lossless Modular JPEG XL codestream.
+  def encode(image, **) = Encoder.new(image, **).encode
+
+  # Reads basic image metadata without decoding pixels.
+  def info(data, **) = BasicInfo.read(data, **)
+
+  # Decodes a JPEG XL codestream or container into an Image.
+  def decode(data, pixel_format: :native, color_space: :original, desired_scale: 1,
+             max_pixels: 100_000_000, max_memory: 2 << 30, strict: true,
+             apply_orientation: true, render_spot_colors: true) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/ParameterLists
+    validate_options!(pixel_format, color_space, desired_scale)
+    frames = Codestream::Reader.new(data, max_pixels:).read_all_headers
+    enforce_memory_limit!(frames.first.basic_info, max_memory)
+    references = Array.new(4)
+    dc_frames = Array.new(4)
+    output = nil
+    displayed = []
+    frames.each do |parsed|
+      frame = parsed.frame_header
+      raw = if frame.encoding == :vardct
+              VarDCT::Decoder.decode(parsed, references:, dc_frames:)
+            else
+              Modular::Decoder.decode_parsed(parsed, render: true, references:)
+            end
+      if frame.type == 1
+        dc_frames[frame.dc_level - 1] = raw
+        next
+      end
+      image = frame.encoding == :modular ? convert_modular_colour(raw, parsed) : raw
+      if frame.type == 2
+        references[frame.save_as_reference] = frame.save_before_colour_transform ? raw : image
+      else
+        composed = Render::Blender.compose(image, frame, references, parsed.basic_info.width, parsed.basic_info.height)
+        if !frame.last && (frame.duration.zero? || !frame.save_as_reference.zero?)
+          references[frame.save_as_reference] = frame.save_before_colour_transform ? raw : composed
+        end
+        rendered = render_spot_colors ? Features::SpotColour.apply(composed) : composed
+        output = apply_orientation ? Render::Orientation.apply(rendered) : rendered
+        if !frame.duration.zero? || frame.last
+          displayed << Frame.new(planes: output.channels, duration: frame.duration, timecode: frame.timecode,
+                                 name: frame.name, blend_info: frame.blend)
+        end
+      end
+    end
+    output ||= raise(CorruptError, "codestream has no display frame")
+    encoding = frames.first.basic_info.metadata.colour_encoding
+    profile = if encoding.want_icc && frames.first.frame_header.colour_transform == :xyb
+                Color::ICCProfile.create(encoding.with(want_icc: false, transfer_function: 8))
+              else
+                frames.first.icc_profile || Color::ICCProfile.create(encoding)
+              end
+    output = output.with(frames: displayed.freeze, icc_profile: profile)
+    output = convert_output_colour(output, color_space)
+    output = downsample(output, desired_scale) unless desired_scale == 1
+    validate_samples!(output, strict)
+  end
+
+  def validate_options!(pixel_format, color_space, desired_scale)
+    raise ArgumentError, "invalid pixel format" unless %i[native rgba8 rgba16 float32].include?(pixel_format)
+    raise ArgumentError, "invalid color space" unless %i[original srgb linear_srgb].include?(color_space)
+    raise ArgumentError, "invalid desired scale" unless [1, 2, 4, 8].include?(desired_scale)
+  end
+  private_class_method :validate_options!
+
+  def enforce_memory_limit!(basic, limit)
+    return unless limit
+
+    channels = 3 + basic.metadata.extra_channels.length
+    estimate = basic.width * basic.height * channels * 64
+    raise ResourceLimitError, "decoded image exceeds memory limit" if estimate > limit
+  end
+  private_class_method :enforce_memory_limit!
+
+  def convert_output_colour(image, target)
+    return image if target == :original
+
+    encoding = image.metadata.colour_encoding
+    channels = image.channels.map do |source|
+      Plane.new(source.width, source.height).tap { |plane| plane.data.replace(source.data) }
+    end
+    if encoding.want_icc
+      Color::Transfer.from_linear!(channels, 13) if target == :srgb
+      return image.with(channels:)
+    end
+
+    intensity = image.metadata.tone_mapping.intensity_target
+    Color::Transfer.to_linear!(channels, encoding.transfer_function, gamma: encoding.gamma,
+                                                                     intensity_target: intensity)
+    Color::Gamut.to_srgb!(channels, encoding)
+    Color::Transfer.from_linear!(channels, 13) if target == :srgb
+    image.with(channels:)
+  end
+  private_class_method :convert_output_colour
+
+  def downsample(image, scale)
+    width = Num.ceil_div(image.width, scale)
+    height = Num.ceil_div(image.height, scale)
+    channels = image.channels.map do |source|
+      Plane.new(width, height).tap do |target|
+        height.times do |y|
+          width.times do |x|
+            target[x, y] = source[[x * scale, source.width - 1].min, [y * scale, source.height - 1].min]
+          end
+        end
+      end
+    end
+    image.with(width:, height:, channels:)
+  end
+  private_class_method :downsample
+
+  def validate_samples!(image, strict)
+    image.channels.each do |plane|
+      plane.data.map! do |value|
+        next value if value.finite?
+        raise CorruptError, "non-finite decoded sample" if strict
+
+        0.0
+      end
+    end
+    image
+  end
+  private_class_method :validate_samples!
+
+  def convert_modular_colour(image, parsed)
+    return image unless parsed.frame_header.colour_transform == :xyb
+
+    opsin = parsed.transform_data.opsin
+    channels = Color::Opsin.to_linear(image.channels, opsin,
+                                      intensity_target: image.metadata.tone_mapping.intensity_target)
+    encoding = image.metadata.colour_encoding
+    return image.with(channels:) if encoding.want_icc
+
+    Color::Transfer.from_linear!(
+      channels, encoding.transfer_function, gamma: encoding.gamma,
+                                            intensity_target: image.metadata.tone_mapping.intensity_target
+    )
+    image.with(channels:)
+  end
+  private_class_method :convert_modular_colour
+end

data/tools/bench.rb

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "../lib/jxl"
+
+root = ENV.fetch("JXL_CORPUS", "/private/tmp/jxl-conformance/testcases")
+names = ENV.fetch("JXL_BENCH_CASES", "alpha_triangles,grayscale,lz77_flower").split(",")
+puts "case                         seconds      MP/s"
+puts "---------------------------- -------- ---------"
+names.each do |name|
+  path = File.join(root, name, "input.jxl")
+  next unless File.file?(path)
+
+  data = File.binread(path)
+  started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  image = JXL.decode(data)
+  elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - started
+  rate = image.width * image.height / elapsed / 1_000_000.0
+  puts format("%<name>-28s %<elapsed>8.3f %<rate>9.3f", name:, elapsed:, rate:)
+end

data/tools/compare_trace.rb

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+unless ARGV.length == 2
+  warn "usage: #{$PROGRAM_NAME} REFERENCE ACTUAL"
+  exit 2
+end
+
+reference_path, actual_path = ARGV
+reference = File.foreach(reference_path)
+actual = File.foreach(actual_path)
+context = []
+line_number = 0
+
+loop do
+  expected = begin
+    reference.next
+  rescue StopIteration
+    nil
+  end
+  received = begin
+    actual.next
+  rescue StopIteration
+    nil
+  end
+  break if expected.nil? && received.nil?
+
+  line_number += 1
+  if expected != received
+    warn "mismatch at line #{line_number}"
+    warn "reference: #{expected&.chomp || '<end of file>'}"
+    warn "actual:    #{received&.chomp || '<end of file>'}"
+    warn "previous #{context.length} lines:"
+    context.each { |line| warn "  #{line.chomp}" }
+    exit 1
+  end
+
+  context << expected
+  context.shift if context.length > 20
+end
+
+puts "matched #{line_number} lines"

data/tools/conformance_report.rb

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "json"
+
+path = ENV.fetch("JXL_CONFORMANCE_RESULTS") do
+  abort "set JXL_CONFORMANCE_RESULTS to the official conformance runner JSON"
+end
+results = JSON.parse(File.read(path))
+
+puts "test case                     | status | max RMSE  | peak"
+puts "------------------------------+--------+-----------+-----------"
+results.each do |result|
+  comparisons = result.filter_map { |key, value| value if key.match?(/\Aframe\d+_compare_npy\z/) }
+  rms = comparisons.filter_map { _1["actual_rmse"] }.max
+  peak = comparisons.filter_map { _1["actual_peak_error"] }.max
+  values = { name: result.fetch("test_id"), status: result["success"] ? "pass" : "FAIL",
+             rms: rms ? format("%.3g", rms) : "-", peak: peak ? format("%.3g", peak) : "-" }
+  puts format("%<name>-30s| %<status>-7s| %<rms>9s | %<peak>9s", **values)
+end
+passed = results.count { _1["success"] }
+puts format("%<name>-30s| %<passed>d/%<total>d", name: "", passed:, total: results.length)
+exit 1 unless passed == results.length

data/tools/fuzz.rb

@@ -0,0 +1,51 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "timeout"
+require_relative "../lib/jxl"
+
+mode = ARGV.fetch(0) { abort "usage: tools/fuzz.rb truncate|bitflip|box" }
+root = ENV.fetch("JXL_CORPUS", "/private/tmp/jxl-conformance/testcases")
+files = Dir.glob(File.join(root, "**", "input.jxl"))
+abort "no JPEG XL inputs under #{root}" if files.empty?
+random = Random.new(Integer(ENV.fetch("SEED", "1"), 10))
+
+def exercise(bytes, label)
+  Timeout.timeout(Integer(ENV.fetch("FUZZ_TIMEOUT", "30"), 10)) { JXL.decode(bytes, strict: false) }
+rescue JXL::Error
+  nil
+rescue StandardError => e
+  warn "#{label}: #{e.class}: #{e.message}"
+  raise
+end
+
+case mode
+when "truncate"
+  files.each do |path|
+    source = File.binread(path)
+    200.times.map { source.bytesize * _1 / 200 }.uniq.each do |length|
+      exercise(source.byteslice(0, length), "#{path}:#{length}")
+    end
+  end
+when "bitflip"
+  Integer(ENV.fetch("FUZZ_ITERATIONS", "10000"), 10).times do |index|
+    path = files[index % files.length]
+    bytes = File.binread(path)
+    position = random.rand(bytes.bytesize)
+    bytes.setbyte(position, bytes.getbyte(position) ^ (1 << random.rand(8)))
+    exercise(bytes, "#{path}:#{index}")
+  end
+when "box"
+  files.each do |path|
+    source = File.binread(path)
+    next unless JXL::Container::Signature.detect(source) == :container
+
+    [0, 1, 7, 8, 0xFFFF_FFFF].each do |size|
+      bytes = source.dup
+      bytes[0, 4] = [size].pack("N")
+      exercise(bytes, "#{path}:box-size-#{size}")
+    end
+  end
+else abort "unknown fuzz mode: #{mode}"
+end
+puts "#{mode}: #{files.length} inputs passed"

data/tools/gen_afv_basis.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+source, target = ARGV
+abort "usage: ruby tools/gen_afv_basis.rb dec_transforms-inl.h TARGET" unless source && target
+
+body = File.read(source)[/k4x4AFVBasis\[16\]\[16\] = \{(.*?)\n  \};/m, 1]
+abort "AFV basis was not found" unless body
+
+values = body.scan(/[-+]?(?:\d+\.\d*|\.\d+)(?:[eE][-+]?\d+)?/).map(&:to_f)
+abort "expected 256 AFV basis values, got #{values.length}" unless values.length == 256
+
+File.binwrite(target, values.pack("e*"))

data/tools/gen_quant_tables.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "zlib"
+
+source, target = ARGV
+abort "usage: ruby tools/gen_quant_tables.rb DUMP TARGET" unless source && target
+
+bytes = File.binread(source)
+abort "quantization dump must contain matching matrix and inverse-matrix halves" unless (bytes.bytesize % 8).zero?
+
+File.binwrite(target, Zlib::Deflate.deflate(bytes.byteslice(0, bytes.bytesize / 2), Zlib::BEST_COMPRESSION))