jxl 1.0.0

data/lib/jxl/codestream/reader.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module JXL
+  module Codestream
+    ParsedHeaders = Data.define(:basic_info, :transform_data, :icc_profile, :frame_header, :toc, :sections)
+
+    class Reader
+      def initialize(data, max_pixels: 100_000_000)
+        @container = Container::Parser.new(data, ignore_brob: true)
+        @stream = @container.codestream
+        @max_pixels = max_pixels
+      end
+
+      def read_headers
+        read_all_headers.first
+      end
+
+      def read_all_headers
+        bits = Bit::Reader.new(@stream, 2)
+        size = Headers::SizeHeader.read(bits, max_pixels: @max_pixels)
+        metadata = Headers::ImageMetadata.read(bits, max_pixels: @max_pixels)
+        basic = BasicInfo.new(width: size.width, height: size.height, metadata:, container: @container,
+                              bits_consumed: bits.bits_read)
+        transform_data = Headers::CustomTransform.read(bits, xyb_encoded: metadata.xyb_encoded)
+        icc_profile = Entropy::ICCStream.read(bits) if metadata.colour_encoding.want_icc
+
+        bits.zero_pad_to_byte
+        offset = 2 + bits.byte_position
+        frames = []
+        loop do
+          raise TruncatedError, "missing frame header" if offset > @stream.bytesize
+
+          frame_bits = Bit::Reader.new(@stream, offset)
+          frame = Headers::FrameHeader.read(frame_bits, metadata:, image_width: size.width, image_height: size.height)
+          toc = Frame::TOC.read(frame_bits, toc_entries(frame))
+          section_start = offset + frame_bits.byte_position
+          sections = read_sections(section_start, toc)
+          frames << ParsedHeaders.new(basic_info: basic, transform_data:, icc_profile:, frame_header: frame,
+                                      toc:, sections:)
+          break if frame.last
+
+          offset = section_start + toc.total_size
+          raise TruncatedError, "missing final frame" if offset >= @stream.bytesize
+        end
+        frames
+      end
+
+      private
+
+      def read_sections(start, toc)
+        raise TruncatedError, "frame sections are truncated" if start + toc.total_size > @stream.bytesize
+
+        toc.offsets.zip(toc.sizes).map { |offset, length| @stream.byteslice(start + offset, length) }
+      end
+
+      def toc_entries(frame)
+        group_dim = 128 << frame.group_size_shift
+        width = frame.encoded_width
+        height = frame.encoded_height
+        groups = Num.ceil_div(width, group_dim) * Num.ceil_div(height, group_dim)
+        dc_groups = Num.ceil_div(frame.blocks_width, group_dim) * Num.ceil_div(frame.blocks_height, group_dim)
+        return 1 if groups == 1 && frame.passes.count.eql?(1)
+
+        2 + dc_groups + (groups * frame.passes.count)
+      end
+    end
+  end
+end

data/lib/jxl/color/gamut.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module JXL
+  module Color
+    module Gamut
+      WHITE_POINTS = { 1 => [0.3127, 0.3290], 10 => [1.0 / 3, 1.0 / 3], 11 => [0.314, 0.351] }.freeze
+      PRIMARIES = ICCProfile::PRIMARIES
+      BRADFORD = ICCProfile::BRADFORD
+      BRADFORD_INVERSE = ICCProfile::BRADFORD_INVERSE
+
+      module_function
+
+      def to_srgb!(channels, encoding)
+        return channels if encoding.colour_space == 1
+
+        source_white = encoding.white_point == 2 ? encoding.white_point_xy : WHITE_POINTS.fetch(encoding.white_point)
+        source_primaries = encoding.primaries == 2 ? encoding.primaries_xy : PRIMARIES.fetch(encoding.primaries)
+        transform = multiply(inverse(rgb_to_xyz(PRIMARIES.fetch(1), WHITE_POINTS.fetch(1))),
+                             multiply(adaptation(source_white, WHITE_POINTS.fetch(1)),
+                                      rgb_to_xyz(source_primaries, source_white)))
+        red, green, blue = channels.first(3).map(&:data)
+        red.length.times do |index|
+          values = [red[index], green[index], blue[index]]
+          red[index] = transform[0].each_with_index.sum { |value, channel| value * values[channel] }
+          green[index] = transform[1].each_with_index.sum { |value, channel| value * values[channel] }
+          blue[index] = transform[2].each_with_index.sum { |value, channel| value * values[channel] }
+        end
+        channels
+      end
+
+      def rgb_to_xyz(primaries, white)
+        matrix = [primaries.map { |x, y| x / y }, Array.new(3, 1.0),
+                  primaries.map { |x, y| (1.0 - x - y) / y }]
+        scales = multiply(inverse(matrix), xy_to_xyz(white))
+        matrix.map { |row| row.each_with_index.map { |value, column| value * scales[column] } }
+      end
+      private_class_method :rgb_to_xyz
+
+      def adaptation(source_white, target_white)
+        source = multiply(BRADFORD, xy_to_xyz(source_white))
+        target = multiply(BRADFORD, xy_to_xyz(target_white))
+        diagonal = Array.new(3) { |y| Array.new(3) { |x| x == y ? target[y] / source[y] : 0.0 } }
+        multiply(BRADFORD_INVERSE, multiply(diagonal, BRADFORD))
+      end
+      private_class_method :adaptation
+
+      def xy_to_xyz(point)
+        x, y = point
+        [x / y, 1.0, (1.0 - x - y) / y]
+      end
+      private_class_method :xy_to_xyz
+
+      def multiply(a, b)
+        return a.map { |row| row.each_with_index.sum { |value, index| value * b[index] } } unless b.first.is_a?(Array)
+
+        Array.new(a.length) do |y|
+          Array.new(b.first.length) do |x|
+            b.length.times.sum { |index| a[y][index] * b[index][x] }
+          end
+        end
+      end
+      private_class_method :multiply
+
+      def inverse(matrix)
+        a, b, c = matrix[0]
+        d, e, f = matrix[1]
+        g, h, i = matrix[2]
+        determinant = (a * ((e * i) - (f * h))) - (b * ((d * i) - (f * g))) + (c * ((d * h) - (e * g)))
+        raise CorruptError, "singular colour primary matrix" if determinant.zero?
+
+        [[(e * i) - (f * h), (c * h) - (b * i), (b * f) - (c * e)],
+         [(f * g) - (d * i), (a * i) - (c * g), (c * d) - (a * f)],
+         [(d * h) - (e * g), (b * g) - (a * h), (a * e) - (b * d)]].map do |row|
+          row.map { _1 / determinant }
+        end
+      end
+      private_class_method :inverse
+    end
+  end
+end

data/lib/jxl/color/icc_profile.rb

@@ -0,0 +1,243 @@
+# frozen_string_literal: true
+
+require "digest/md5"
+
+module JXL
+  module Color
+    module ICCProfile # rubocop:disable Metrics/ModuleLength
+      WHITE_POINTS = { 1 => [0.3127, 0.3290], 10 => [1.0 / 3, 1.0 / 3], 11 => [0.314, 0.351] }.freeze
+      PRIMARIES = {
+        1 => [[0.639998686, 0.330010138], [0.300003784, 0.600003357], [0.150002046, 0.059997204]],
+        9 => [[0.708, 0.292], [0.170, 0.797], [0.131, 0.046]],
+        11 => [[0.680, 0.320], [0.265, 0.690], [0.150, 0.060]]
+      }.freeze
+      BRADFORD = [[0.8951, 0.2664, -0.1614], [-0.7502, 1.7135, 0.0367],
+                  [0.0389, -0.0685, 1.0296]].freeze
+      BRADFORD_INVERSE = [[0.9869929, -0.1470543, 0.1599627], [0.4323053, 0.5183603, 0.0492912],
+                          [-0.0085287, 0.0400428, 0.9684867]].freeze
+      TRANSFER_NAMES = { 1 => "709", 8 => "Lin", 13 => "SRG", 16 => "PQ", 17 => "DCI", 18 => "HLG" }.freeze
+      INTENT_NAMES = %w[Per Rel Sat Abs].freeze
+
+      module_function
+
+      def create(encoding)
+        raise UnsupportedFeatureError, "ICC profile for embedded encoding" if encoding.want_icc
+        unless [0, 1].include?(encoding.colour_space)
+          raise UnsupportedFeatureError, "ICC profile colour space #{encoding.colour_space}"
+        end
+
+        white = encoding.white_point == 2 ? encoding.white_point_xy : WHITE_POINTS.fetch(encoding.white_point)
+        primaries = if encoding.colour_space == 1
+                      PRIMARIES[1]
+                    elsif encoding.primaries == 2
+                      encoding.primaries_xy
+                    else
+                      PRIMARIES.fetch(encoding.primaries)
+                    end
+        raise CorruptError, "missing custom ICC white point" unless white
+        raise CorruptError, "missing custom ICC primaries" unless primaries
+
+        header = create_header(encoding)
+        table = +"\0\0\0\0".b
+        tags = +"".b
+        entries = []
+        add_tag!(entries, tags, "desc", mluc(description(encoding)))
+        add_tag!(entries, tags, "cprt", mluc("CC0"))
+        white_xyz = encoding.colour_space == 1 ? xy_to_xyz(white) : [0.964203, 1.0, 0.824905]
+        add_tag!(entries, tags, "wtpt", xyz_tag(white_xyz))
+        if encoding.colour_space.zero?
+          adaptation = adapt_to_d50(white)
+          add_tag!(entries, tags, "chad", fixed_tag("sf32", adaptation.flatten))
+          add_cicp!(entries, tags, encoding)
+          rgb_matrix(primaries, white).transpose.each_with_index do |column, index|
+            add_tag!(entries, tags, %w[rXYZ gXYZ bXYZ][index], xyz_tag(column))
+          end
+        end
+        trc_offset = tags.bytesize
+        trc = transfer_tag(encoding)
+        tags << trc << ("\0" * ((-trc.bytesize) & 3))
+        trc_names = encoding.colour_space == 1 ? ["kTRC"] : %w[rTRC gTRC bTRC]
+        trc_names.each { entries << [_1, trc_offset, tags.bytesize - trc_offset] }
+
+        table[0, 4] = [entries.length].pack("N")
+        base = header.bytesize + 4 + (entries.length * 12)
+        entries.each { |name, offset, size| table << name << [base + offset, size].pack("N2") }
+        profile = header + table + tags
+        profile[0, 4] = [profile.bytesize].pack("N")
+        checksum = profile.dup
+        checksum[44, 4] = checksum[64, 4] = "\0" * 4
+        profile[84, 16] = Digest::MD5.digest(checksum)
+        profile
+      end
+
+      def create_header(encoding)
+        header = "\0" * 128
+        header[4, 4] = "jxl "
+        header[8, 4] = [0x04400000].pack("N")
+        header[12, 4] = "mntr"
+        header[16, 4] = encoding.colour_space == 1 ? "GRAY" : "RGB "
+        header[20, 4] = "XYZ "
+        header[24, 12] = [2019, 12, 1, 0, 0, 0].pack("n6")
+        header[36, 8] = "acspAPPL"
+        header[64, 4] = [encoding.rendering_intent].pack("N")
+        header[68, 12] = [0x0000F6D6, 0x00010000, 0x0000D32D].pack("N3")
+        header[80, 4] = "jxl "
+        header
+      end
+      private_class_method :create_header
+
+      def add_tag!(entries, tags, name, data)
+        offset = tags.bytesize
+        tags << data << ("\0" * ((-data.bytesize) & 3))
+        entries << [name, offset, tags.bytesize - offset]
+      end
+      private_class_method :add_tag!
+
+      def add_cicp!(entries, tags, encoding)
+        return unless encoding.white_point == 1 && encoding.primaries != 2 && encoding.transfer_function
+
+        primaries = encoding.primaries == 11 ? 12 : encoding.primaries
+        add_tag!(entries, tags, "cicp", "cicp\0\0\0\0".b + [primaries, encoding.transfer_function, 0, 1].pack("C4"))
+      end
+      private_class_method :add_cicp!
+
+      def mluc(text)
+        "mluc".b + [0, 1, 12].pack("N3") + "enUS" + [text.bytesize * 2, 28].pack("N2") +
+          text.bytes.flat_map { [0, _1] }.pack("C*")
+      end
+      private_class_method :mluc
+
+      def xyz_tag(values) = fixed_tag("XYZ ", values)
+      private_class_method :xyz_tag
+
+      def fixed_tag(type, values)
+        type.b + [0].pack("N") + values.map { fixed(_1) }.pack("N*")
+      end
+      private_class_method :fixed_tag
+
+      def fixed(value)
+        rounded = (Num.f32(value) * 65_536).round
+        unless rounded.between?(-2_147_483_648, 2_147_483_647)
+          raise CorruptError, "ICC fixed-point value is out of range"
+        end
+
+        Num.u32(rounded)
+      end
+      private_class_method :fixed
+
+      def transfer_tag(encoding)
+        return sampled_transfer_tag(encoding.transfer_function) if [16, 18].include?(encoding.transfer_function)
+
+        params = if encoding.gamma
+                   [1.0 / (encoding.gamma / 10_000_000.0)]
+                 else
+                   case encoding.transfer_function
+                   when 13 then [2.4, 1.0 / 1.055, 0.055 / 1.055, 1.0 / 12.92, 0.04045]
+                   when 1 then [1.0 / 0.45, 1.0 / 1.099, 0.099 / 1.099, 1.0 / 4.5, 0.081]
+                   when 8 then [1.0, 1.0, 0.0, 1.0, 0.0]
+                   when 17 then [2.6, 1.0, 0.0, 1.0, 0.0]
+                   else raise UnsupportedFeatureError, "ICC transfer function #{encoding.transfer_function}"
+                   end
+                 end
+        type = params.one? ? 0 : 3
+        "para".b + [0, type, 0].pack("Nn2") + params.map { fixed(_1) }.pack("N*")
+      end
+      private_class_method :transfer_tag
+
+      def sampled_transfer_tag(function)
+        count = 4096
+        values = Array.new(count) do |index|
+          linear = Transfer.decode(index.fdiv(count - 1), function)
+          (Num.clamp(linear, 0.0, 1.0) * 65_535).round
+        end
+        "curv".b + [0, count].pack("N2") + values.pack("n*")
+      end
+      private_class_method :sampled_transfer_tag
+
+      def description(encoding)
+        return "sRGB" if encoding.colour_space.zero? && encoding.white_point == 1 &&
+                         encoding.primaries == 1 && encoding.transfer_function == 13
+
+        space = encoding.colour_space == 1 ? "Gra" : "RGB"
+        white = if encoding.white_point == 2
+                  encoding.white_point_xy.join(";")
+                else
+                  { 1 => "D65", 10 => "EER", 11 => "DCI" }.fetch(encoding.white_point)
+                end
+        intent = INTENT_NAMES.fetch(encoding.rendering_intent)
+        transfer = if encoding.gamma
+                     "g#{encoding.gamma / 10_000_000.0}"
+                   else
+                     TRANSFER_NAMES.fetch(encoding.transfer_function)
+                   end
+        parts = [space, white]
+        if encoding.colour_space.zero?
+          primary = if encoding.primaries == 2
+                      encoding.primaries_xy.flatten.join(";")
+                    else
+                      { 1 => "SRG", 9 => "202", 11 => "DCI" }.fetch(encoding.primaries)
+                    end
+          parts << primary
+        end
+        (parts + [intent, transfer]).join("_")
+      end
+      private_class_method :description
+
+      def rgb_matrix(primaries, white)
+        matrix = [primaries.map(&:first), primaries.map(&:last),
+                  primaries.map { |x, y| 1.0 - x - y }]
+        scales = multiply(inverse(matrix), xy_to_xyz(white))
+        to_xyz = matrix.map { |row| row.each_with_index.map { |value, x| f32(value * scales[x]) } }
+        multiply(adapt_to_d50(white), to_xyz)
+      end
+      private_class_method :rgb_matrix
+
+      def adapt_to_d50(white)
+        source = multiply(BRADFORD, xy_to_xyz(white))
+        target = multiply(BRADFORD, [0.96422, 1.0, 0.82521])
+        diagonal = Array.new(3) { |y| Array.new(3) { |x| x == y ? f32(target[y] / source[y]) : 0.0 } }
+        multiply(BRADFORD_INVERSE, multiply(diagonal, BRADFORD))
+      end
+      private_class_method :adapt_to_d50
+
+      def xy_to_xyz(point)
+        x, y = point
+        [f32(x / y), 1.0, f32((1.0 - x - y) / y)]
+      end
+      private_class_method :xy_to_xyz
+
+      def multiply(a, b)
+        unless b.first.is_a?(Array)
+          return a.map do |row|
+            f32(row.each_with_index.sum { |value, index| f32(value) * f32(b[index]) })
+          end
+        end
+
+        Array.new(a.length) do |y|
+          Array.new(b.first.length) do |x|
+            f32(b.length.times.sum { |index| f32(a[y][index]) * f32(b[index][x]) })
+          end
+        end
+      end
+      private_class_method :multiply
+
+      def inverse(matrix)
+        a, b, c = matrix[0]
+        d, e, f = matrix[1]
+        g, h, i = matrix[2]
+        determinant = (a * ((e * i) - (f * h))) - (b * ((d * i) - (f * g))) + (c * ((d * h) - (e * g)))
+        raise CorruptError, "singular ICC primary matrix" if determinant.zero?
+
+        [[(e * i) - (f * h), (c * h) - (b * i), (b * f) - (c * e)],
+         [(f * g) - (d * i), (a * i) - (c * g), (c * d) - (a * f)],
+         [(d * h) - (e * g), (b * g) - (a * h), (a * e) - (b * d)]].map do |row|
+          row.map { f32(_1 / determinant) }
+        end
+      end
+      private_class_method :inverse
+
+      def f32(value) = Num.f32(value)
+      private_class_method :f32
+    end
+  end
+end

data/lib/jxl/color/opsin.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module JXL
+  module Color
+    module Opsin
+      module_function
+
+      def to_linear(channels, transform, intensity_target: 255.0)
+        output = Array.new(3) { Plane.new(channels[0].width, channels[0].height) }
+        matrix = transform.inverse_matrix.map { _1 * (255.0 / intensity_target) }
+        bias_roots = transform.biases.map { Math.cbrt(_1) }
+        channels[0].data.length.times do |index|
+          x = channels[0].data[index]
+          y = channels[1].data[index]
+          b = channels[2].data[index]
+          mixed = [((y + x - bias_roots[0])**3) + transform.biases[0],
+                   ((y - x - bias_roots[1])**3) + transform.biases[1],
+                   ((b - bias_roots[2])**3) + transform.biases[2]]
+          3.times do |channel|
+            offset = channel * 3
+            output[channel].data[index] = matrix[offset, 3].each_with_index.sum { |value, c| value * mixed[c] }
+          end
+        end
+        output + channels.drop(3)
+      end
+    end
+  end
+end

data/lib/jxl/color/transfer.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module JXL
+  module Color
+    module Transfer
+      module_function
+
+      def from_linear!(channels, function, gamma: nil, intensity_target: 255.0)
+        channels.first(3).each do |plane|
+          plane.data.map! { encode(_1, function, gamma:, intensity_target:) }
+        end
+        channels
+      end
+
+      def encode(value, function, gamma: nil, intensity_target: 255.0)
+        return value if function == 8
+        return value.positive? ? value**(gamma / 10_000_000.0) : 0.0 if function.nil? && gamma
+        return value.positive? ? value**(1.0 / 2.6) : 0.0 if function == 17
+        return bt709(value) if function == 1
+        return pq(value, intensity_target) if function == 16
+        return hlg(value) if function == 18
+        raise UnsupportedFeatureError, "transfer function #{function}" unless function == 13
+
+        sign = value.negative? ? -1.0 : 1.0
+        magnitude = value.abs
+        sign * (magnitude <= 0.0031308 ? 12.92 * magnitude : (1.055 * (magnitude**(1.0 / 2.4))) - 0.055)
+      end
+
+      def to_linear!(channels, function, gamma: nil, intensity_target: 255.0)
+        channels.first(3).each do |plane|
+          plane.data.map! { decode(_1, function, gamma:, intensity_target:) }
+        end
+        channels
+      end
+
+      def decode(value, function, gamma: nil, intensity_target: 255.0)
+        return value if function == 8
+        return signed_power(value, 10_000_000.0 / gamma) if function.nil? && gamma
+        return signed_power(value, 2.6) if function == 17
+        return value < 0.081 ? value / 4.5 : ((value + 0.099) / 1.099)**(1.0 / 0.45) if function == 1
+        return inverse_pq(value, intensity_target) if function == 16
+        return inverse_hlg(value) if function == 18
+        raise UnsupportedFeatureError, "transfer function #{function}" unless function == 13
+
+        sign = value.negative? ? -1.0 : 1.0
+        magnitude = value.abs
+        sign * (magnitude <= 0.04045 ? magnitude / 12.92 : ((magnitude + 0.055) / 1.055)**2.4)
+      end
+
+      def bt709(value)
+        value < 0.018 ? 4.5 * value : (1.099 * (value**0.45)) - 0.099
+      end
+      private_class_method :bt709
+
+      def pq(value, intensity_target)
+        return 0.0 if value.zero?
+
+        sign = value.negative? ? -1.0 : 1.0
+        m1 = 2610.0 / 16_384
+        m2 = (2523.0 / 4096) * 128
+        scaled = (value.abs * intensity_target / 10_000.0)**m1
+        sign * ((((3424.0 / 4096) + (scaled * (2413.0 / 4096) * 32)) /
+                 (1.0 + (scaled * (2392.0 / 4096) * 32)))**m2)
+      end
+      private_class_method :pq
+
+      def hlg(value)
+        return 0.0 if value.zero?
+
+        sign = value.negative? ? -1.0 : 1.0
+        magnitude = value.abs
+        encoded = if magnitude <= 1.0 / 12
+                    Math.sqrt(3.0 * magnitude)
+                  else
+                    (0.17883277 * Math.log((12 * magnitude) - (1 - (4 * 0.17883277)))) + 0.5599107295
+                  end
+        sign * encoded
+      end
+      private_class_method :hlg
+
+      def inverse_pq(value, intensity_target)
+        sign = value.negative? ? -1.0 : 1.0
+        m1 = 2610.0 / 16_384
+        m2 = (2523.0 / 4096) * 128
+        encoded = value.abs**(1.0 / m2)
+        numerator = [encoded - (3424.0 / 4096), 0.0].max
+        denominator = ((2413.0 / 4096) * 32) - (encoded * (2392.0 / 4096) * 32)
+        sign * ((numerator / denominator)**(1.0 / m1)) * 10_000.0 / intensity_target
+      end
+      private_class_method :inverse_pq
+
+      def inverse_hlg(value)
+        sign = value.negative? ? -1.0 : 1.0
+        magnitude = value.abs
+        linear = if magnitude <= 0.5
+                   magnitude * magnitude / 3.0
+                 else
+                   (Math.exp((magnitude - 0.5599107295) / 0.17883277) + (1 - (4 * 0.17883277))) / 12.0
+                 end
+        sign * linear
+      end
+      private_class_method :inverse_hlg
+
+      def signed_power(value, exponent) = (value.negative? ? -1.0 : 1.0) * (value.abs**exponent)
+      private_class_method :signed_power
+    end
+  end
+end

data/lib/jxl/color/ycbcr.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module JXL
+  module Color
+    module YCbCr
+      module_function
+
+      def to_rgb(channels, frame)
+        full = channels.first(3).each_with_index.map do |plane, channel|
+          hshift, vshift = frame.chroma_subsampling[channel]
+          hshift.times { plane = double_horizontal(plane) }
+          vshift.times { plane = double_vertical(plane) }
+          crop(plane, frame.encoded_width, frame.encoded_height)
+        end
+        output = Array.new(3) { Plane.new(frame.encoded_width, frame.encoded_height) }
+        full[0].data.length.times do |index|
+          cb = full[0].data[index]
+          y = full[1].data[index] + (128.0 / 255)
+          cr = full[2].data[index]
+          output[0].data[index] = y + (1.402 * cr)
+          output[1].data[index] = y - ((0.114 * 1.772 / 0.587) * cb) - ((0.299 * 1.402 / 0.587) * cr)
+          output[2].data[index] = y + (1.772 * cb)
+        end
+        output + channels.drop(3)
+      end
+
+      def double_horizontal(source)
+        Plane.new(source.width * 2, source.height).tap do |output|
+          source.height.times do |y|
+            source.width.times do |x|
+              current = 0.75 * source[x, y]
+              output[x * 2, y] = current + (0.25 * source[[x - 1, 0].max, y])
+              output[(x * 2) + 1, y] = current + (0.25 * source[[x + 1, source.width - 1].min, y])
+            end
+          end
+        end
+      end
+      private_class_method :double_horizontal
+
+      def double_vertical(source)
+        Plane.new(source.width, source.height * 2).tap do |output|
+          source.height.times do |y|
+            source.width.times do |x|
+              current = 0.75 * source[x, y]
+              output[x, y * 2] = current + (0.25 * source[x, [y - 1, 0].max])
+              output[x, (y * 2) + 1] = current + (0.25 * source[x, [y + 1, source.height - 1].min])
+            end
+          end
+        end
+      end
+      private_class_method :double_vertical
+
+      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/container/box.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module JXL
+  module Container
+    Box = Data.define(:type, :payload, :size, :offset, :uuid)
+  end
+end