jxl 1.0.0

data/lib/jxl/container/parser.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module JXL
+  module Container
+    class Parser
+      attr_reader :codestream, :metadata, :level
+
+      def initialize(data, ignore_brob: false)
+        @data = data.b
+        @metadata = {}
+        @level = 5
+        @boxes = []
+        parse(ignore_brob)
+      end
+
+      def each_box(&block)
+        return @boxes.each unless block
+
+        @boxes.each(&block)
+      end
+
+      private
+
+      def parse(ignore_brob)
+        case Signature.detect(@data)
+        when :codestream then @codestream = @data
+        when :container then parse_container(ignore_brob)
+        else raise SignatureError, "not a JPEG XL stream"
+        end
+      end
+
+      def parse_container(ignore_brob)
+        offset = 0
+        while offset < @data.bytesize
+          box, offset = read_box(offset)
+          @boxes << box
+        end
+        validate_signature_box
+        collect_contents(ignore_brob)
+      end
+
+      def read_box(offset)
+        ensure_available(offset, 8)
+        size32, type = @data.byteslice(offset, 8).unpack("Na4")
+        header_size = 8
+        size = size32
+        if size32 == 1
+          ensure_available(offset, 16)
+          size = @data.unpack1("Q>", offset: offset + 8)
+          header_size = 16
+        elsif size32.zero?
+          size = @data.bytesize - offset
+        end
+
+        uuid = nil
+        if type == "uuid"
+          ensure_available(offset, header_size + 16)
+          uuid = @data.byteslice(offset + header_size, 16)
+          header_size += 16
+        end
+        raise CorruptError, "box size smaller than header" if size < header_size
+
+        ensure_available(offset, size)
+        payload = @data.byteslice(offset + header_size, size - header_size)
+        [Box.new(type:, payload:, size:, offset:, uuid:), offset + size]
+      end
+
+      def ensure_available(offset, length)
+        return if offset >= 0 && length >= 0 && offset + length <= @data.bytesize
+
+        raise TruncatedError, "truncated JPEG XL box"
+      end
+
+      def validate_signature_box
+        first = @boxes.first
+        return if first&.type == "JXL " && first.size == 12 && first.payload == "\r\n\x87\n".b
+
+        raise SignatureError, "invalid JPEG XL container signature"
+      end
+
+      def collect_contents(ignore_brob)
+        chunks = []
+        chunk_kind = nil
+        expected_part = 0
+        final_part_seen = false
+
+        @boxes.drop(1).each do |box|
+          case box.type
+          when "ftyp" then validate_file_type(box)
+          when "jxll" then read_level(box)
+          when "jxlc"
+            raise CorruptError, "mixed jxlc and jxlp boxes" if chunk_kind == :parts
+            raise CorruptError, "multiple jxlc boxes" unless chunks.empty?
+
+            chunk_kind = :single
+            chunks << box.payload
+          when "jxlp"
+            raise CorruptError, "mixed jxlc and jxlp boxes" if chunk_kind == :single
+            raise CorruptError, "jxlp after final part" if final_part_seen
+
+            chunk_kind = :parts
+            index = box.payload&.unpack1("N") || raise(TruncatedError, "missing jxlp index")
+            final_part_seen = !index.nobits?(0x8000_0000)
+            raise CorruptError, "out-of-order jxlp box" unless (index & 0x7FFF_FFFF) == expected_part
+
+            expected_part += 1
+            chunks << box.payload.byteslice(4..)
+          when "Exif" then @metadata[:exif] = box.payload
+          when "xml " then @metadata[:xmp] = box.payload
+          when "jumb" then @metadata[:jumbf] = box.payload
+          when "jbrd" then @metadata[:jpeg_reconstruction] = box.payload
+          when "brob"
+            raise UnsupportedFeatureError, "Brotli-compressed box" unless ignore_brob
+          end
+        end
+        raise CorruptError, "missing final jxlp box" if chunk_kind == :parts && !final_part_seen
+        raise CorruptError, "missing JPEG XL codestream box" if chunks.empty?
+
+        @codestream = chunks.join.b
+      end
+
+      def validate_file_type(box)
+        raise CorruptError, "invalid JPEG XL file type box" unless box.payload&.start_with?("jxl \x00\x00\x00\x00".b)
+      end
+
+      def read_level(box)
+        valid = box.payload&.bytesize == 1 && [5, 10].include?(box.payload.getbyte(0))
+        raise CorruptError, "invalid jxll box" unless valid
+
+        @level = box.payload.getbyte(0)
+      end
+    end
+  end
+end

data/lib/jxl/container/signature.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module JXL
+  module Container
+    module Signature
+      CODESTREAM = "\xFF\x0A".b
+      CONTAINER = "\x00\x00\x00\x0CJXL \r\n\x87\n".b
+
+      module_function
+
+      def detect(data)
+        return :codestream if data.start_with?(CODESTREAM)
+        return :container if data.start_with?(CONTAINER)
+
+        :unknown
+      end
+    end
+  end
+end

data/lib/jxl/dct.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module JXL
+  module DCT
+    module_function
+
+    SQRT2 = Math.sqrt(2.0)
+
+    def inverse_matrix(size)
+      @inverse_matrices ||= {}
+      @inverse_matrices[size] ||= Array.new(size) do |x|
+        Array.new(size) do |frequency|
+          frequency.zero? ? 1.0 : SQRT2 * Math.cos(((x + 0.5) * frequency * Math::PI) / size)
+        end.freeze
+      end.freeze
+    end
+
+    def forward_matrix(size)
+      @forward_matrices ||= {}
+      @forward_matrices[size] ||= inverse_matrix(size).transpose.map { |row| row.map { _1 / size }.freeze }.freeze
+    end
+
+    def idct1d(coefficients)
+      multiply(inverse_matrix(coefficients.length), coefficients)
+    end
+
+    def dct1d(samples)
+      multiply(forward_matrix(samples.length), samples)
+    end
+
+    def idct2d(coefficients, width, height)
+      transform2d(coefficients, width, height, inverse_matrix(width), inverse_matrix(height))
+    end
+
+    def dct2d(samples, width, height)
+      transform2d(samples, width, height, forward_matrix(width), forward_matrix(height))
+    end
+
+    def resample_scale(from, to, frequency)
+      raise ArgumentError, "invalid DCT resampling ratio" unless to == from * 8
+
+      scale = 1.0
+      size = to
+      while size > from
+        scale /= Math.cos((frequency * Math::PI) / (2 * size))
+        size /= 2
+      end
+      scale
+    end
+
+    def transform2d(values, width, height, horizontal, vertical) # rubocop:disable Metrics/AbcSize
+      raise ArgumentError, "block dimensions do not match" unless values.length == width * height
+
+      rows = Array.new(values.length)
+      height.times do |y|
+        width.times do |x|
+          row = horizontal[x]
+          sum = 0.0
+          width.times { |frequency| sum += row[frequency] * values[(y * width) + frequency] }
+          rows[(y * width) + x] = sum
+        end
+      end
+      columns = Array.new(values.length)
+      height.times do |y|
+        width.times do |x|
+          row = vertical[y]
+          sum = 0.0
+          height.times { |frequency| sum += row[frequency] * rows[(frequency * width) + x] }
+          columns[(y * width) + x] = sum
+        end
+      end
+      columns
+    end
+    private_class_method :transform2d
+
+    def multiply(matrix, vector)
+      matrix.map { |row| row.each_with_index.sum { |value, i| value * vector[i] } }
+    end
+    private_class_method :multiply
+  end
+end

data/lib/jxl/decoder.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module JXL
+  Event = Data.define(:type, :basic_info, :frame, :image) do
+    def width = basic_info&.width || image&.width
+    def height = basic_info&.height || image&.height
+  end
+
+  class Decoder
+    EVENTS = %i[basic_info color_encoding frame full_image].freeze
+
+    def initialize(**options)
+      @options = options
+      @buffer = +"".b
+      @events = []
+      @subscriptions = EVENTS
+      @finished = false
+      @decoded = false
+    end
+
+    # Selects which decoder events are queued.
+    def subscribe(*events)
+      unknown = events - EVENTS
+      raise ArgumentError, "unknown decoder event: #{unknown.first}" unless unknown.empty?
+
+      @subscriptions = events
+      self
+    end
+
+    # Appends compressed input and emits any available metadata events.
+    def feed(bytes)
+      raise IOError, "decoder is finished" if @finished
+      raise ArgumentError, "input must be a String" unless bytes.is_a?(String)
+
+      @buffer << bytes.b
+      limit = @options.fetch(:max_memory, 2 << 30)
+      raise ResourceLimitError, "compressed input exceeds memory limit" if limit && @buffer.bytesize > limit
+
+      read_basic_info
+      read_image
+      self
+    end
+
+    # Marks input complete and emits frame and full-image events.
+    def finish
+      @finished = true
+      return self if @decoded
+
+      read_basic_info(force: true)
+      read_image(force: true)
+      self
+    end
+
+    # Returns and removes the next subscribed event.
+    def next_event = @events.shift
+
+    private
+
+    def read_basic_info(force: false)
+      return if @basic_info
+
+      @basic_info = BasicInfo.read(@buffer, max_pixels: @options.fetch(:max_pixels, 100_000_000))
+      push(Event.new(type: :basic_info, basic_info: @basic_info, frame: nil, image: nil))
+      push(Event.new(type: :color_encoding, basic_info: @basic_info, frame: nil, image: nil))
+    rescue FormatError
+      raise if force
+    end
+
+    def read_image(force: false)
+      return unless @basic_info
+      return if @decoded
+
+      image = JXL.decode(@buffer, **@options)
+      image.frames.each { |frame| push(Event.new(type: :frame, basic_info: @basic_info, frame:, image: nil)) }
+      push(Event.new(type: :full_image, basic_info: @basic_info, frame: nil, image:))
+      @decoded = true
+    rescue FormatError
+      raise if force
+    end
+
+    def push(event)
+      @events << event if @subscriptions.include?(event.type)
+    end
+  end
+end

data/lib/jxl/encoder.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+module JXL
+  class Encoder # rubocop:disable Metrics/ClassLength
+    SIZE_DISTRIBUTION = Headers::SizeHeader::DIMENSION
+
+    def initialize(image, bits_per_sample: 8)
+      raise ArgumentError, "encoder requires RGB" unless image.channels.length >= 3
+      raise ArgumentError, "unsupported bit depth" unless bits_per_sample.between?(1, 16)
+
+      @image = image
+      @bits_per_sample = bits_per_sample
+    end
+
+    def encode
+      sections = frame_sections
+      writer = Bit::Writer.new
+      write_image_header(writer)
+      writer.align
+      write_frame_header(writer)
+      writer.write(1, 0).align # TOC is not permuted
+      sections.each { Bit::Field.write_u32(writer, _1.bytesize, *Frame::TOC_DISTRIBUTIONS) }
+      writer.align
+      Container::Signature::CODESTREAM + writer.bytes + sections.join
+    end
+
+    private
+
+    def write_image_header(writer)
+      write_size(writer)
+      writer.write(1, 0) # custom metadata
+      writer.write(1, 0) # no optional metadata
+      writer.write(1, 0) # integer samples
+      Bit::Field.write_u32(writer, @bits_per_sample, Bit::Field.val(8), Bit::Field.val(10),
+                           Bit::Field.val(12), Bit::Field.bits_offset(6, 1))
+      writer.write(1, 1) # 16-bit modular buffer
+      Bit::Field.write_u32(writer, 0, Bit::Field.val(0), Bit::Field.val(1),
+                           Bit::Field.bits_offset(4, 2), Bit::Field.bits_offset(12, 1))
+      writer.write(1, 0) # RGB, not XYB
+      writer.write(1, 1) # default sRGB colour encoding
+      Bit::Field.write_u64(writer, 0) # metadata extensions
+      writer.write(1, 1) # default transform data
+    end
+
+    def write_size(writer)
+      writer.write(1, 0)
+      Bit::Field.write_u32(writer, @image.height, *SIZE_DISTRIBUTION)
+      writer.write(3, 0)
+      Bit::Field.write_u32(writer, @image.width, *SIZE_DISTRIBUTION)
+    end
+
+    def write_frame_header(writer)
+      writer.write(1, 0).write(2, 0).write(1, 1) # custom regular Modular frame
+      Bit::Field.write_u64(writer, 0)
+      writer.write(1, 0) # no colour transform
+      Bit::Field.write_u32(writer, 1, *Headers::FRAME_UPSAMPLING_DISTRIBUTION)
+      writer.write(2, 3) # 1024-pixel groups
+      Bit::Field.write_u32(writer, 1, Bit::Field.val(1), Bit::Field.val(2),
+                           Bit::Field.val(3), Bit::Field.bits_offset(3, 4))
+      writer.write(1, 0) # full-size frame
+      Bit::Field.write_u32(writer, 0, Bit::Field.val(0), Bit::Field.val(1),
+                           Bit::Field.val(2), Bit::Field.bits_offset(2, 3))
+      writer.write(1, 1) # last frame
+      Bit::Field.write_u32(writer, 0, Bit::Field.val(0), Bit::Field.bits(4),
+                           Bit::Field.bits_offset(5, 16), Bit::Field.bits_offset(10, 48))
+      writer.write(1, 0).write(1, 0).write(2, 0) # no loop filters
+      Bit::Field.write_u64(writer, 0) # loop-filter extensions
+      Bit::Field.write_u64(writer, 0) # frame extensions
+    end
+
+    def frame_sections # rubocop:disable Metrics/AbcSize
+      channels = transformed_channels
+      return [single_group_section(channels)] if @image.width <= 1024 && @image.height <= 1024
+
+      groups_x = Num.ceil_div(@image.width, 1024)
+      groups_y = Num.ceil_div(@image.height, 1024)
+      groups = Array.new(groups_x * groups_y) do |group|
+        x = (group % groups_x) * 1024
+        y = (group / groups_x) * 1024
+        width = [1024, @image.width - x].min
+        height = [1024, @image.height - y].min
+        channels.flat_map { residuals(region(_1, x, y, width, height), width, height) }
+      end
+      packed = groups.flatten.map { Num.pack_signed(_1) }
+      entropy = Entropy::Encoder.new(packed)
+      global = global_section(entropy)
+      dc_groups = Num.ceil_div(Num.ceil_div(@image.width, 8), 1024) *
+                  Num.ceil_div(Num.ceil_div(@image.height, 8), 1024)
+      group_sections = groups.map do |group|
+        group_section(entropy, group.map { Num.pack_signed(_1) })
+      end
+      [global, *Array.new(dc_groups + 1, "".b), *group_sections]
+    end
+
+    def single_group_section(channels)
+      packed = channels.flat_map { residuals(_1, @image.width, @image.height) }.map { Num.pack_signed(_1) }
+      entropy = Entropy::Encoder.new(packed)
+      writer = Bit::Writer.new
+      writer.write(1, 1).write(1, 1) # default DC quantization and global MA tree
+      write_tree(writer)
+      entropy.write_header(writer)
+      write_group_header(writer)
+      entropy.write_symbols(writer)
+      writer.bytes
+    end
+
+    def global_section(entropy)
+      writer = Bit::Writer.new
+      writer.write(1, 1).write(1, 1)
+      write_tree(writer)
+      entropy.write_header(writer)
+      write_group_header(writer)
+      writer.bytes
+    end
+
+    def group_section(entropy, values)
+      writer = Bit::Writer.new
+      writer.write(1, 1).write(1, 1)
+      Bit::Field.write_u32(writer, 0, Bit::Field.val(0), Bit::Field.val(1),
+                           Bit::Field.bits_offset(4, 2), Bit::Field.bits_offset(8, 18))
+      entropy.write_symbols(writer, values)
+      writer.bytes
+    end
+
+    def write_tree(writer)
+      tree = Entropy::Encoder.new([0, 5, 0, 0, 0])
+      tree.write(writer, context_count: 6)
+    end
+
+    def write_group_header(writer)
+      writer.write(1, 1).write(1, 1) # global tree and default weighted header
+      Bit::Field.write_u32(writer, 1, Bit::Field.val(0), Bit::Field.val(1),
+                           Bit::Field.bits_offset(4, 2), Bit::Field.bits_offset(8, 18))
+      Bit::Field.write_u32(writer, 0, *Array.new(4) { |value| Bit::Field.val(value) })
+      Bit::Field.write_u32(writer, 0, Bit::Field.bits(3), Bit::Field.bits_offset(6, 8),
+                           Bit::Field.bits_offset(10, 72), Bit::Field.bits_offset(13, 1096))
+      Bit::Field.write_u32(writer, 6, Bit::Field.val(6), Bit::Field.bits(2),
+                           Bit::Field.bits_offset(4, 2), Bit::Field.bits_offset(6, 10))
+    end
+
+    def transformed_channels # rubocop:disable Metrics/AbcSize
+      maximum = (1 << @bits_per_sample) - 1
+      source = @image.channels.first(3).map { |plane| plane.data.map { sample(_1, maximum) } }
+      length = @image.width * @image.height
+      Array.new(3) { Array.new(length) }.tap do |output|
+        length.times do |index|
+          red, green, blue = source.map { _1[index] }
+          second = red - blue
+          temporary = blue + (second >> 1)
+          third = green - temporary
+          output[0][index] = Num.i32(temporary + (third >> 1))
+          output[1][index] = Num.i32(second)
+          output[2][index] = Num.i32(third)
+        end
+      end
+    end
+
+    def sample(value, maximum)
+      value = (value * maximum).round if value.is_a?(Float)
+      raise ArgumentError, "sample is outside bit depth" unless value.between?(0, maximum)
+
+      value
+    end
+
+    def region(values, x, y, width, height)
+      height.times.flat_map { |row| values.slice(((y + row) * @image.width) + x, width) }
+    end
+
+    def residuals(values, width, height)
+      plane = Plane.new(width, height)
+      values.each_with_index.map do |value, index|
+        x = index % width
+        y = index / width
+        residual = Num.i32(value - Modular::Predictor.predict(5, plane, x, y))
+        plane[x, y] = value
+        residual
+      end
+    end
+  end
+end