jxl 1.0.0

data/lib/jxl/io/npy.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module JXL
+  module IO
+    module NPY
+      MAGIC = "\x93NUMPY".b
+      FORMATS = {
+        "<f4" => "e*",
+        "<f8" => "E*",
+        "|u1" => "C*",
+        "<u2" => "v*",
+        "<i4" => "l<*"
+      }.freeze
+
+      module_function
+
+      def load(path)
+        data = File.binread(path)
+        raise FormatError, "invalid NPY signature" unless data.start_with?(MAGIC)
+
+        major = data.getbyte(6)
+        header_offset, header_length = header_location(data, major)
+        header = data.byteslice(header_offset, header_length)
+        descriptor = header[/['"]descr['"]\s*:\s*['"]([^'"]+)['"]/, 1]
+        fortran = header[/['"]fortran_order['"]\s*:\s*(True|False)/, 1]
+        raise FormatError, "invalid NPY header" unless descriptor && fortran
+        raise UnsupportedFeatureError, "Fortran-order NPY array" if fortran == "True"
+
+        shape = parse_shape(header)
+        format = FORMATS[descriptor] || raise(UnsupportedFeatureError, "NPY dtype #{descriptor}")
+        values = data.byteslice((header_offset + header_length)..).unpack(format)
+        expected = shape.inject(1, :*)
+        unless values.length == expected
+          raise CorruptError,
+                "NPY shape contains #{expected} values, got #{values.length}"
+        end
+
+        [shape, values]
+      end
+
+      def dump(path, shape, values, descriptor: "<f4")
+        format = FORMATS[descriptor] || raise(UnsupportedFeatureError, "NPY dtype #{descriptor}")
+        expected = shape.inject(1, :*)
+        raise ArgumentError, "shape does not match values" unless expected == values.length
+
+        shape_text = shape.length == 1 ? "#{shape.first}," : shape.join(", ")
+        dictionary = "{'descr': '#{descriptor}', 'fortran_order': False, 'shape': (#{shape_text}), }"
+        padding = 16 - ((MAGIC.bytesize + 4 + dictionary.bytesize + 1) % 16)
+        header = "#{dictionary}#{' ' * padding}\n"
+        File.binwrite(path, MAGIC + [1, 0, header.bytesize].pack("CCv") + header + values.pack(format))
+      end
+
+      def dump_image(path, image)
+        frame_planes = image.frames.empty? ? [image.channels] : image.frames.map(&:planes)
+        channels = image.num_color_channels + image.metadata.extra_channels.length
+        values = frame_planes.flat_map { |planes| planes.first(channels).map(&:data).transpose.flatten }
+        dump(path, [frame_planes.length, image.height, image.width, channels], values)
+      end
+
+      def header_location(data, major)
+        case major
+        when 1 then [10, data.unpack1("v", offset: 8)]
+        when 2, 3 then [12, data.unpack1("V", offset: 8)]
+        else raise UnsupportedFeatureError, "NPY version #{major}"
+        end
+      end
+      private_class_method :header_location
+
+      def parse_shape(header)
+        text = header[/['"]shape['"]\s*:\s*\(([^)]*)\)/, 1]
+        raise FormatError, "invalid NPY shape" unless text
+
+        text.split(",").filter_map do |part|
+          next if part.strip.empty?
+
+          Integer(part, 10)
+        end
+      end
+      private_class_method :parse_shape
+    end
+  end
+end

data/lib/jxl/io/pam.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module JXL
+  module IO
+    module PAM
+      module_function
+
+      def dump(image)
+        header = "P7\nWIDTH #{image.width}\nHEIGHT #{image.height}\nDEPTH 4\nMAXVAL 255\nTUPLTYPE RGB_ALPHA\nENDHDR\n"
+        header.b + image.to_rgba8
+      end
+    end
+  end
+end

data/lib/jxl/io/pfm.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module JXL
+  module IO
+    module PFM
+      module_function
+
+      def dump(image)
+        grayscale = image.num_color_channels == 1
+        planes = grayscale ? [image.channels.first] : image.channels.first(3)
+        values = []
+        (image.height - 1).downto(0) do |y|
+          image.width.times do |x|
+            planes.each { |plane| values << plane[x, y] }
+          end
+        end
+        "#{grayscale ? 'Pf' : 'PF'}\n#{image.width} #{image.height}\n-1.0\n".b + values.pack("e*")
+      end
+    end
+  end
+end

data/lib/jxl/io/pgx.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module JXL
+  module IO
+    module PGX
+      module_function
+
+      def dump(image)
+        raise UnsupportedFeatureError, "PGX requires grayscale without extra channels" \
+          unless image.num_color_channels == 1 && image.extra_channels.empty?
+
+        bits = image.metadata.bit_depth.bits_per_sample
+        raise UnsupportedFeatureError, "PGX supports at most 16 bits" if bits > 16
+
+        bits = bits <= 8 ? 8 : 16
+        maximum = (1 << bits) - 1
+        pixels = image.channels.first.data.map { (Num.clamp(_1, 0.0, 1.0) * maximum).round }
+        "PG ML + #{bits} #{image.width} #{image.height}\n".b + pixels.pack(bits == 8 ? "C*" : "n*")
+      end
+    end
+  end
+end

data/lib/jxl/io/png.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require "zlib"
+
+module JXL
+  module IO
+    module PNG
+      SIGNATURE = "\x89PNG\r\n\x1A\n".b
+
+      module_function
+
+      def dump(image) # rubocop:disable Metrics/AbcSize
+        planes, colour_type = output_planes(image)
+        header = [image.width, image.height, 8, colour_type, 0, 0, 0].pack("N2C5")
+        pixels = (image.width * image.height).times.flat_map do |pixel|
+          planes.map { (Num.clamp(_1.data[pixel], 0.0, 1.0) * 255).round }
+        end
+        stride = image.width * planes.length
+        rows = pixels.each_slice(stride).map { "\0".b + _1.pack("C*") }.join
+        SIGNATURE + chunk("IHDR", header) + chunk("iCCP", icc(image)) +
+          chunk("IDAT", Zlib::Deflate.deflate(rows)) + chunk("IEND", "".b)
+      end
+
+      def load(data) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+        raise FormatError, "invalid PNG signature" unless data.start_with?(SIGNATURE)
+
+        chunks = read_chunks(data)
+        width, height, depth, colour, compression, filter, interlace = chunks.fetch("IHDR").first.unpack("N2C5")
+        unless depth == 8 && [0, 2, 4, 6].include?(colour) && [compression, filter, interlace].all?(&:zero?)
+          raise UnsupportedFeatureError, "only non-interlaced 8-bit PNG input is supported"
+        end
+
+        components = { 0 => 1, 2 => 3, 4 => 2, 6 => 4 }.fetch(colour)
+        stride = width * components
+        raw = Zlib::Inflate.inflate(chunks.fetch("IDAT").join)
+        raise TruncatedError, "PNG pixels are truncated" unless raw.bytesize == height * (stride + 1)
+
+        previous = Array.new(stride, 0)
+        pixels = height.times.flat_map do |row|
+          start = row * (stride + 1)
+          type = raw.getbyte(start)
+          scanline = unfilter(raw.byteslice(start + 1, stride).bytes, previous, components, type)
+          previous = scanline
+        end
+        colour_components = [components, 3].min
+        channels = colour_components.times.map do |channel|
+          pixels.drop(channel).each_slice(components).map(&:first)
+        end
+        channels = [channels.first] * 3 if colour_components < 3
+        planes = channels.map do |values|
+          Plane.new(width, height).tap { |plane| plane.data.replace(values.map { _1 / 255.0 }) }
+        end
+        Image.new(width:, height:, channels: planes, metadata: Headers::ImageMetadata.defaults)
+      rescue KeyError, Zlib::Error => e
+        raise FormatError, "invalid PNG: #{e.message}"
+      end
+
+      def chunk(type, data)
+        body = type.b + data
+        [data.bytesize].pack("N") + body + [Zlib.crc32(body)].pack("N")
+      end
+      private_class_method :chunk
+
+      def output_planes(image)
+        grayscale = image.num_color_channels == 1
+        colour = grayscale ? [image.channels.first] : image.channels.first(3)
+        alpha_index = image.metadata.extra_channels.index { _1.type.zero? }
+        alpha = image.extra_channels[alpha_index] if alpha_index
+        colour_type = if grayscale
+                        alpha ? 4 : 0
+                      else
+                        alpha ? 6 : 2
+                      end
+        [alpha ? colour + [alpha] : colour, colour_type]
+      end
+      private_class_method :output_planes
+
+      def read_chunks(data)
+        chunks = Hash.new { |hash, key| hash[key] = [] }
+        offset = SIGNATURE.bytesize
+        while offset < data.bytesize
+          raise TruncatedError, "PNG chunk is truncated" if offset + 12 > data.bytesize
+
+          length = data.unpack1("N", offset:)
+          type = data.byteslice(offset + 4, 4)
+          payload = data.byteslice(offset + 8, length)
+          crc = data.unpack1("N", offset: offset + 8 + length)
+          raise TruncatedError, "PNG chunk is truncated" unless payload && crc
+          raise FormatError, "invalid PNG checksum" unless Zlib.crc32(type + payload) == crc
+
+          chunks[type] << payload
+          offset += length + 12
+        end
+        chunks
+      end
+      private_class_method :read_chunks
+
+      def unfilter(bytes, previous, components, type) # rubocop:disable Metrics/CyclomaticComplexity
+        bytes.each_index do |index|
+          left = index >= components ? bytes[index - components] : 0
+          top = previous[index]
+          top_left = index >= components ? previous[index - components] : 0
+          predictor = case type
+                      when 0 then 0
+                      when 1 then left
+                      when 2 then top
+                      when 3 then (left + top) / 2
+                      when 4 then paeth(left, top, top_left)
+                      else raise FormatError, "invalid PNG filter"
+                      end
+          bytes[index] = (bytes[index] + predictor) & 255
+        end
+        bytes
+      end
+      private_class_method :unfilter
+
+      def paeth(left, top, top_left)
+        base = left + top - top_left
+        distances = [(base - left).abs, (base - top).abs, (base - top_left).abs]
+        [left, top, top_left][distances.index(distances.min)]
+      end
+      private_class_method :paeth
+
+      def icc(image)
+        raise ArgumentError, "image has no ICC profile" unless image.icc_profile
+
+        "jxl\0\0".b + Zlib::Deflate.deflate(image.icc_profile)
+      end
+      private_class_method :icc
+    end
+  end
+end

data/lib/jxl/io/ppm.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module JXL
+  module IO
+    module PPM
+      module_function
+
+      def dump(image)
+        grayscale = image.num_color_channels == 1
+        planes = grayscale ? [image.channels.first] : image.channels.first(3)
+        pixels = (image.width * image.height).times.flat_map do |pixel|
+          planes.map { (Num.clamp(_1.data[pixel], 0.0, 1.0) * 255).round }
+        end
+        "#{grayscale ? 'P5' : 'P6'}\n#{image.width} #{image.height}\n255\n".b + pixels.pack("C*")
+      end
+
+      def load(data) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+        offset = 0
+        magic, offset = token(data, offset)
+        width, offset = token(data, offset)
+        height, offset = token(data, offset)
+        maximum, offset = token(data, offset)
+        raise FormatError, "unsupported PNM format" unless %w[P5 P6].include?(magic)
+
+        width = Integer(width, 10)
+        height = Integer(height, 10)
+        maximum = Integer(maximum, 10)
+        raise FormatError, "unsupported PNM range" unless maximum.between?(1, 65_535)
+
+        offset += 1
+        offset += 1 if data.getbyte(offset - 1) == 13 && data.getbyte(offset) == 10
+        count = width * height * (magic == "P6" ? 3 : 1)
+        bytes = maximum < 256 ? data.byteslice(offset, count)&.bytes : data.byteslice(offset, count * 2)&.unpack("n*")
+        raise TruncatedError, "PNM pixels are truncated" unless bytes&.length == count
+
+        channels = if magic == "P6"
+                     3.times.map { |channel| bytes.drop(channel).each_slice(3).map(&:first) }
+                   else
+                     [bytes] * 3
+                   end
+        planes = channels.map do |values|
+          Plane.new(width, height).tap { |plane| plane.data.replace(values.map { _1 / maximum.to_f }) }
+        end
+        Image.new(width:, height:, channels: planes, metadata: Headers::ImageMetadata.defaults)
+      end
+
+      def token(data, offset) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+        loop do
+          offset += 1 while data.getbyte(offset)&.chr&.match?(/\s/)
+          break unless data.getbyte(offset) == 35
+
+          offset = data.index("\n", offset) || data.bytesize
+        end
+        finish = offset
+        finish += 1 while data.getbyte(finish) && !data.getbyte(finish).chr.match?(/\s/)
+        raise TruncatedError, "PNM header is truncated" if finish == offset
+
+        [data.byteslice(offset, finish - offset), finish]
+      end
+      private_class_method :token
+    end
+  end
+end