texel 0.1.0

data/lib/texel.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+require_relative "texel/version"
+require_relative "texel/errors"
+require_relative "texel/info"
+require_relative "texel/pixel_data"
+require_relative "texel/image"
+require_relative "texel/color_transform"
+require_relative "texel/native"
+require_relative "texel/resampler"
+require_relative "texel/image_transformations"
+require_relative "texel/codec"
+require_relative "texel/registry"
+require_relative "texel/source_reader"
+require_relative "texel/codecs/qoi"
+require_relative "texel/codecs/stb"
+
+module Texel
+  class << self
+    def load(source, channels: nil, dtype: nil, flip_y: false, color_space: nil)
+      validate_channels!(channels) if channels
+      validate_dtype!(dtype) if dtype
+      validate_color_space!(color_space) if color_space
+
+      input = SourceReader.read(source)
+      format = detect_format!(input)
+      codec = Registry.codec_for!(format, operation: :decode)
+      image = codec.decode(input.bytes, channels: channels, dtype: dtype, format: format)
+      image = image.dup_with(color_space: color_space) if color_space
+      flip_y ? image.flip_y : image
+    end
+
+    def info(source)
+      input = SourceReader.read(source)
+      format = detect_format!(input)
+      Registry.codec_for!(format, operation: :decode).info(input.bytes, format: format)
+    end
+
+    def encode(image, format, **options)
+      raise FormatError, "expected a Texel::Image" unless image.is_a?(Image)
+
+      normalized = normalize_format(format)
+      encoded = String(Registry.codec_for!(normalized, operation: :encode).encode(image, normalized, **options))
+      encoded = encoded.dup.force_encoding(Encoding::BINARY) unless encoded.encoding == Encoding::BINARY
+      encoded.freeze
+    end
+
+    def save(image, destination, format: nil, **options)
+      resolved_format = format || destination_format(destination)
+      bytes = encode(image, resolved_format, **options)
+      return write_io(destination, bytes) if destination.respond_to?(:write)
+
+      File.binwrite(destination, bytes)
+      destination
+    rescue SystemCallError => e
+      raise EncodeError, "could not write image: #{e.message}"
+    end
+
+    def load_all(paths, threads: 4, **options)
+      unless threads.is_a?(Integer) && threads.positive?
+        raise FormatError, "threads must be a positive integer"
+      end
+
+      sources = paths.to_a
+      return [] if sources.empty?
+
+      queue = Queue.new
+      sources.each_index { |index| queue << index }
+      results = Array.new(sources.length)
+      errors = Array.new(sources.length)
+      workers = [threads, sources.length].min.times.map do
+        Thread.new do
+          loop do
+            index = queue.pop(true)
+            results[index] = load(sources[index], **options)
+          rescue ThreadError
+            break
+          rescue StandardError => e
+            errors[index] = e
+          end
+        end
+      end
+      workers.each(&:join)
+      raise errors.compact.first if errors.any?
+
+      results
+    end
+
+    private
+
+    def detect_format!(input)
+      Registry.detect(input.bytes.byteslice(0, 32).to_s, extension: input.extension) ||
+        raise(FormatError, "unknown image format")
+    end
+
+    def destination_format(destination)
+      unless destination.respond_to?(:to_path) || destination.is_a?(String)
+        raise FormatError, "format is required when saving to an IO"
+      end
+
+      path = destination.respond_to?(:to_path) ? destination.to_path : destination
+      extension = SourceReader.extension_for_path(path)
+      raise FormatError, "destination has no image format extension" unless extension
+
+      normalize_format(extension)
+    end
+
+    def normalize_format(format)
+      normalized = format.to_s.delete_prefix(".").downcase.to_sym
+      normalized == :jpeg ? :jpg : normalized
+    end
+
+    def write_io(io, bytes)
+      written = io.write(bytes)
+      raise EncodeError, "IO wrote #{written} of #{bytes.bytesize} bytes" if written.is_a?(Integer) && written != bytes.bytesize
+
+      io
+    end
+
+    def validate_channels!(channels)
+      return if channels.is_a?(Integer) && channels.between?(1, 4)
+
+      raise FormatError, "channels must be between 1 and 4"
+    end
+
+    def validate_dtype!(dtype)
+      return if Image::DTYPE_SIZES.key?(dtype)
+
+      raise FormatError, "unsupported dtype #{dtype.inspect}"
+    end
+
+    def validate_color_space!(color_space)
+      return if Image::COLOR_SPACES.include?(color_space)
+
+      raise FormatError, "unsupported color space #{color_space.inspect}"
+    end
+  end
+
+  Registry.register(:png, magic: "\x89PNG\r\n\x1a\n".b, codec: Codecs::Stb)
+  Registry.register(:jpg, magic: "\xff\xd8\xff".b, codec: Codecs::Stb, extensions: %w[jpg jpeg])
+  Registry.register(:gif, magic: ["GIF87a".b, "GIF89a".b], codec: Codecs::Stb)
+  Registry.register(:bmp, magic: "BM".b, codec: Codecs::Stb)
+  Registry.register(
+    :tga,
+    magic: lambda do |bytes|
+      bytes.bytesize >= 18 && [0, 1].include?(bytes.getbyte(1)) &&
+        [1, 2, 3, 9, 10, 11].include?(bytes.getbyte(2)) &&
+        [8, 15, 16, 24, 32].include?(bytes.getbyte(16)) &&
+        bytes.byteslice(12, 4).unpack("S<2").all?(&:positive?)
+    end,
+    codec: Codecs::Stb
+  )
+  Registry.register(:hdr, magic: ["#?RADIANCE".b, "#?RGBE".b], codec: Codecs::Stb)
+  Registry.register(:psd, magic: "8BPS".b, codec: Codecs::Stb)
+  Registry.register(:qoi, magic: "qoif".b, codec: Codecs::Qoi)
+  Registry.register(:ktx2, magic: "\xabKTX 20\xbb\r\n\x1a\n".b, codec: nil, required_gem: "texel-ktx")
+  Registry.register(:exr, magic: "\x76\x2f\x31\x01".b, codec: nil, required_gem: "texel-exr")
+  Registry.register(
+    :webp,
+    magic: ->(bytes) { bytes.start_with?("RIFF".b) && bytes.byteslice(8, 4) == "WEBP".b },
+    codec: nil,
+    required_gem: "texel-webp"
+  )
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: texel
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Yudai Takada
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: |-
+  Texel provides a compact immutable image container, stb-based codecs, QOI,
+  color and channel conversion, mipmap generation, and GPU upload helpers.
+email:
+- t.yudai92@gmail.com
+executables: []
+extensions:
+- ext/texel/extconf.rb
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- Rakefile
+- ext/texel/extconf.rb
+- ext/texel/shim.c
+- ext/texel/shim.h
+- ext/texel/texel_native.c
+- ext/texel/vendor/README.md
+- ext/texel/vendor/stb_image.h
+- ext/texel/vendor/stb_image_resize2.h
+- ext/texel/vendor/stb_image_write.h
+- lib/texel.rb
+- lib/texel/codec.rb
+- lib/texel/codecs/qoi.rb
+- lib/texel/codecs/stb.rb
+- lib/texel/color_transform.rb
+- lib/texel/errors.rb
+- lib/texel/gl.rb
+- lib/texel/half_float.rb
+- lib/texel/image.rb
+- lib/texel/image_transformations.rb
+- lib/texel/info.rb
+- lib/texel/native.rb
+- lib/texel/pixel_data.rb
+- lib/texel/registry.rb
+- lib/texel/resampler.rb
+- lib/texel/source_reader.rb
+- lib/texel/version.rb
+- lib/texel/wgpu.rb
+homepage: https://github.com/ydah/texel
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/ydah/texel
+  changelog_uri: https://github.com/ydah/texel/releases
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.6
+specification_version: 4
+summary: Texture-oriented image decoding, conversion, and GPU upload
+test_files: []