qoi 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3738d729da49df1ab6812d1e56dd6a972262a62e40ae5638e820f8ab5ab68437
+  data.tar.gz: 8f9a11be98af90afca9270b4fb613e1b4252c0be9352a584b983ef43d6db06db
+SHA512:
+  metadata.gz: 964ae465da63c1f2b1865534a5ba490edd436e853141515435e16cbf4d05bda39a206b87b953eabd31cb04bf5c71212a4d7d555707ee1864dd464956c733bb36
+  data.tar.gz: df6ed5e9bf4e425a158cacd695cb4e1d38572aff49c2db090f9dde5d57a6cd5378e610ac8e3a9921d5130f800f86c8725a39142b4aca23909167d7448d4165aa

data/.github/workflows/ci.yml

@@ -0,0 +1,33 @@
+name: CI
+
+on:
+  push:
+  pull_request:
+
+jobs:
+  ruby-versions:
+    uses: ruby/actions/.github/workflows/ruby_versions.yml@master
+
+  test:
+    needs: ruby-versions
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        ruby: ${{ fromJson(needs.ruby-versions.outputs.versions) }}
+
+    steps:
+      - uses: actions/checkout@v4
+      
+      - name: Set up Ruby
+        uses: ruby/setup-ruby-pkgs@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+          apt-get: "haveged libyaml-dev"
+          brew: libyaml
+          vcpkg: libyaml
+      
+      - name: Install dependencies
+        run: bundle install --jobs 4 --retry 3
+
+      - name: Run tests
+        run: bundle exec rake test

data/.github/workflows/release.yml

@@ -0,0 +1,52 @@
+name: Publish gem to rubygems.org
+
+on:
+  push:
+    tags:
+      - 'v*'
+
+permissions:
+  contents: read
+
+jobs:
+  push:
+    if: github.repository == 'tenderlove/qoi'
+    runs-on: ubuntu-latest
+
+    environment:
+      name: rubygems.org
+      url: https://rubygems.org/gems/qoi
+
+    permissions:
+      contents: write
+      id-token: write
+
+    strategy:
+      matrix:
+        ruby: ["ruby"]
+
+    steps:
+      - name: Harden Runner
+        uses: step-security/harden-runner@v2
+        with:
+          egress-policy: audit
+
+      - uses: actions/checkout@v4
+
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+
+      - name: Install dependencies
+        run: bundle install --jobs 4 --retry 3
+
+      - name: Publish to RubyGems
+        uses: rubygems/release-gem@v1
+
+      - name: Create GitHub release
+        run: |
+          tag_name="$(git describe --tags --abbrev=0)"
+          gh release create "${tag_name}" --verify-tag --generate-notes
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

data/.gitignore

@@ -0,0 +1,2 @@
+test/images
+Gemfile.lock

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,77 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to make participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, sex characteristics, gender identity and expression,
+level of experience, education, socio-economic status, nationality, personal
+appearance, race, religion, or sexual identity and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+  advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies within all project spaces, and it also applies when
+an individual is representing the project or its community in public spaces.
+Examples of representing a project or community include using an official
+project e-mail address, posting via an official social media account, or acting
+as an appointed representative at an online or offline event. Representation of
+a project may be further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at aaron.patterson at gmail.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see
+https://www.contributor-covenant.org/faq
+

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec

data/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright Aaron Patterson
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

data/README.md

@@ -0,0 +1,70 @@
+# QOI
+
+A Ruby implementation of the [QOI (Quite OK Image)](https://qoiformat.org) format.
+
+## Installation
+
+Just add it to your Gemfile!
+
+```ruby
+gem 'qoi'
+```
+
+## Usage
+
+### Decoding
+
+```ruby
+require 'qoi'
+
+# From file
+image = QOI::Image.from_file("photo.qoi")
+
+# From binary string
+image = QOI::Image.from_buffer(qoi_data)
+
+# Access image properties
+image.width      # => 800
+image.height     # => 600
+image.channels   # => 4 (RGBA) or 3 (RGB)
+image.colorspace # => 0 (sRGB) or 1 (linear)
+```
+
+### Encoding
+
+```ruby
+# Create a new image
+image = QOI::Image.new(100, 100, QOI::Channels::RGBA, QOI::Colorspace::SRGB)
+
+# Set pixels
+image.set_rgba(0, 0, 255, 0, 0, 255)  # red pixel at (0,0)
+image.set_rgb(1, 0, 0, 255, 0)        # green pixel at (1,0)
+
+# Encode to QOI
+qoi_data = image.encode
+File.binwrite("output.qoi", qoi_data)
+```
+
+### Converting from PNG with ChunkyPNG
+
+```ruby
+require 'qoi'
+require 'chunky_png'
+
+png = ChunkyPNG::Image.from_file("input.png")
+image = QOI::Image.new(png.width, png.height, QOI::Channels::RGBA, QOI::Colorspace::SRGB, png.to_rgba_stream)
+File.binwrite("output.qoi", image.encode)
+```
+
+### Reading Pixels
+
+```ruby
+image.rgba(x, y)  # => [r, g, b, a]
+image.rgb(x, y)   # => [r, g, b]
+image.pixel(x, y) # => 0xRRGGBBAA (packed integer)
+image.buffer      # => raw pixel data as binary string
+```
+
+## License
+
+MIT

data/Rakefile

@@ -0,0 +1,57 @@
+ENV["MT_NO_PLUGINS"] = "1"
+
+require "rake/testtask"
+require "rake/clean"
+require "bundler"
+Bundler::GemHelper.install_tasks
+
+def download from, to
+  Dir.mkdir 'tmp' unless File.directory?("tmp")
+
+  require "net/http"
+  require "net/https"
+  require "fileutils"
+
+  FileUtils.mkdir_p File.dirname(to)
+
+  url = URI.parse from
+  client = Net::HTTP.new(url.host, url.port)
+  client.use_ssl = true
+  client.start do |http|
+    http.request_get(url.path) do |res|
+      File.open(to, "w") do |f|
+        res.read_body do |segment|
+          f.write segment
+        end
+      end
+    end
+  end
+end
+
+TEST_IMAGES_URL = "https://qoiformat.org/qoi_test_images.zip"
+TEST_IMAGES_ZIP = "test/images/tests.zip"
+TEST_IMAGES_FOLDER = "test/images/qoi_test_images"
+
+file TEST_IMAGES_FOLDER => TEST_IMAGES_ZIP do |t|
+  require "zip"
+  Zip::File.open(t.source) do |zip|
+    zip.each do |entry|
+      entry.extract File.join("test", "images", entry.name)
+    end
+  end
+end
+
+file TEST_IMAGES_ZIP do |t|
+  download TEST_IMAGES_URL, t.name
+end
+
+CLEAN.include [TEST_IMAGES_ZIP, TEST_IMAGES_FOLDER]
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/**/*_test.rb']
+  t.verbose = true
+  t.warning = true
+end
+
+task :test => TEST_IMAGES_FOLDER

data/lib/qoi/version.rb

@@ -0,0 +1,3 @@
+module QOI
+  VERSION = "1.0.0"
+end

data/lib/qoi.rb

@@ -0,0 +1,467 @@
+# frozen_string_literal: true
+# encoding: ascii-8bit
+
+# QOI (Quite OK Image) format encoder and decoder.
+#
+# QOI is a fast, lossless image compression format that offers decent
+# compression ratios while being simple to implement.
+#
+# @example Decoding a QOI file
+#   image = QOI::Image.from_file("photo.qoi")
+#   puts "#{image.width}x#{image.height}, #{image.channels} channels"
+#
+# @example Encoding an image to QOI
+#   image = QOI::Image.new(100, 100, 4, QOI::Colorspace::SRGB)
+#   image.set_rgba(0, 0, 255, 0, 0, 255)  # Set pixel at (0,0) to red
+#   qoi_data = image.encode
+#
+# @see https://qoiformat.org QOI Format Specification
+module QOI
+  autoload :VERSION, "qoi/version"
+
+  # Exception classes for QOI operations.
+  module Errors
+    # Base class for all QOI errors.
+    class Error < StandardError; end
+
+    # Raised when the QOI file format is invalid or corrupted.
+    class FormatError < Error; end
+
+    # Raised when the buffer size doesn't match the image dimensions.
+    class BufferSizeError < Error; end
+  end
+
+  # Channel count constants for QOI images.
+  module Channels
+    # 3-channel RGB image (no alpha).
+    RGB = 3
+
+    # 4-channel RGBA image (with alpha).
+    RGBA = 4
+  end
+
+  # Colorspace constants for QOI images.
+  module Colorspace
+    # sRGB with linear alpha.
+    SRGB = 0
+
+    # All channels are linear.
+    ALL = 1
+  end
+
+  # Represents a QOI image with pixel data.
+  #
+  # Images can be created by decoding QOI data or by constructing a new
+  # blank image. Pixel data is stored as a binary string in row-major order,
+  # with either 3 bytes (RGB) or 4 bytes (RGBA) per pixel.
+  class Image
+    def self.pixel_hash px # :nodoc:
+      r = (px >> 24) & 0xFF
+      g = (px >> 16) & 0xFF
+      b = (px >> 8) & 0xFF
+      a = px & 0xFF
+      (r * 3 + g * 5 + b * 7 + a * 11) % 64
+    end
+
+    def self.decode ctx, reader # :nodoc:
+      index = 0
+      raise Errors::FormatError unless "qoif" == reader.read(ctx, index, 4)
+      index += 4
+
+      width, height, channels, colorspace = reader.read(ctx, index, 10).unpack("NNCC")
+      index += 10
+
+      total_pixels = width * height
+      buff = String.new(capacity: total_pixels * channels, encoding: Encoding::BINARY)
+      writer = channels == 3 ? RGBWriter : RGBAWriter
+
+      # Pixel format: 0xRRGGBBAA (RGBA, high to low bits)
+      px = 0x000000FF
+      seen = Array.new(64, 0)
+      seen[pixel_hash(px)] = px
+
+      pixels_decoded = 0
+
+      while true
+        byte = reader.getbyte(ctx, index)
+        index += 1
+        break if pixels_decoded >= total_pixels
+
+        if byte == 0xFE # QOI_OP_RGB
+          px = (reader.read_uint24(ctx, index) << 8) | (px & 0xFF)
+          index += 3
+          seen[pixel_hash(px)] = px
+          writer.write(px, buff)
+
+        elsif byte == 0xFF # QOI_OP_RGBA
+          px = reader.read_uint32(ctx, index)
+          index += 4
+          seen[pixel_hash(px)] = px
+          writer.write(px, buff)
+
+        elsif byte & 0xC0 == 0xC0 # QOI_OP_RUN
+          run = byte & 0x3F
+          (run + 1).times { writer.write(px, buff) }
+          pixels_decoded += run
+
+        elsif byte & 0xC0 == 0x80 # QOI_OP_LUMA
+          dg = (byte & 0x3F) - 32
+          byte2 = reader.getbyte(ctx, index); index += 1
+          dr_dg = (byte2 >> 4) - 8
+          db_dg = (byte2 & 0x0F) - 8
+
+          r = (((px >> 24) & 0xFF) + dg + dr_dg) & 0xFF
+          g = (((px >> 16) & 0xFF) + dg) & 0xFF
+          b = (((px >> 8) & 0xFF) + dg + db_dg) & 0xFF
+          px = (r << 24) | (g << 16) | (b << 8) | (px & 0xFF)
+          seen[pixel_hash(px)] = px
+          writer.write(px, buff)
+
+        elsif byte & 0xC0 == 0x40 # QOI_OP_DIFF
+          dr = ((byte >> 4) & 0x03) - 2
+          dg = ((byte >> 2) & 0x03) - 2
+          db = (byte & 0x03) - 2
+
+          r = (((px >> 24) & 0xFF) + dr) & 0xFF
+          g = (((px >> 16) & 0xFF) + dg) & 0xFF
+          b = (((px >> 8) & 0xFF) + db) & 0xFF
+          px = (r << 24) | (g << 16) | (b << 8) | (px & 0xFF)
+          seen[pixel_hash(px)] = px
+          writer.write(px, buff)
+
+        else # QOI_OP_INDEX
+          px = seen[byte]
+          writer.write(px, buff)
+        end
+
+        pixels_decoded += 1
+      end
+
+      new width, height, channels, colorspace, buff
+    end
+
+    def self.encode width, height, channels, colorspace, buffer
+      out = String.new(capacity: 14 + width * height * 5 + 8, encoding: Encoding::BINARY)
+
+      # Header
+      out << "qoif"
+      [width, height, channels, colorspace].pack("NNCC", buffer: out)
+
+      # Pixel format: 0xRRGGBBAA (RGBA, high to low bits)
+      previous_pixel = 0x000000FF
+      pixel_lut = Array.new(64, 0)
+      reader = channels == 3 ? RGBReader : RGBAReader
+
+      run = 0
+      total_pixels = width * height * channels
+      last_pixel = total_pixels - channels
+      pos = 0
+
+      while true
+        break unless pos < total_pixels
+
+        pixel = reader.read(buffer, pos)
+
+        if pixel == previous_pixel
+          run += 1
+          if run == 62 || pos == last_pixel
+            out << (0xC0 | (run - 1))
+            run = 0
+          end
+        else
+          if run > 0
+            out << (0xC0 | (run - 1))
+            run = 0
+          end
+
+          index = pixel_hash(pixel)
+          if pixel_lut[index] == pixel
+            out << index
+          else
+            pixel_lut[index] = pixel
+
+            # if the alpha is the same
+            if (pixel & 0xFF) == (previous_pixel & 0xFF)
+              vr = (pixel >> 24) - (previous_pixel >> 24)
+              vg = ((pixel >> 16) & 0xFF) - ((previous_pixel >> 16) & 0xFF)
+              vb = ((pixel >> 8) & 0xFF) - ((previous_pixel >> 8) & 0xFF)
+
+              # Handle wraparound (e.g., 255->0 is +1, not -255)
+              vr = vr - 256 if vr > 127
+              vr = vr + 256 if vr < -127
+              vg = vg - 256 if vg > 127
+              vg = vg + 256 if vg < -127
+              vb = vb - 256 if vb > 127
+              vb = vb + 256 if vb < -127
+
+              vg_r = vr - vg
+              vg_b = vb - vg
+
+              if vr > -3 && vr < 2 && vg > -3 && vg < 2 && vb > -3 && vb < 2
+                # QOI_OP_DIFF
+                out << (0x40 | ((vr + 2) << 4) | ((vg + 2) << 2) | (vb + 2))
+              elsif vg_r > -9 && vg_r < 8 && vg > -33 && vg < 32 && vg_b > -9 && vg_b < 8
+                # QOI_OP_LUMA
+                [0x80 | (vg + 32), ((vg_r + 8) << 4) | (vg_b + 8)].pack("CC", buffer: out)
+              else
+                # QOI_OP_RGB
+                [0xFE_00_00_00 | (pixel >> 8)].pack("N", buffer: out)
+              end
+            else
+              # QOI_OP_RGBA
+              [0xFF, pixel].pack("CN", buffer: out)
+            end
+          end
+        end
+
+        previous_pixel = pixel
+        pos += channels
+      end
+
+      # Flush final run
+      if run > 0
+        out << (0xC0 | (run - 1)).chr
+      end
+
+      # End marker
+      out << "\x00\x00\x00\x00\x00\x00\x00\x01"
+
+      out
+    end
+
+
+    module RGBReader # :nodoc:
+      def self.read buff, pos
+        (buff.getbyte(pos) << 24) | (buff.getbyte(pos + 1) << 16) | (buff.getbyte(pos + 2) << 8) | 0xFF
+      end
+
+      def self.rgba buff, pos
+        [buff.getbyte(pos), buff.getbyte(pos + 1), buff.getbyte(pos + 2), 255]
+      end
+
+      def self.rgb buff, pos
+        [buff.getbyte(pos), buff.getbyte(pos + 1), buff.getbyte(pos + 2)]
+      end
+    end
+
+    module RGBAReader # :nodoc:
+      def self.read buff, pos
+        buff.unpack1("N", offset: pos)
+      end
+
+      def self.rgba buff, pos
+        [buff.getbyte(pos), buff.getbyte(pos + 1), buff.getbyte(pos + 2), buff.getbyte(pos + 3)]
+      end
+
+      def self.rgb buff, pos
+        [buff.getbyte(pos), buff.getbyte(pos + 1), buff.getbyte(pos + 2)]
+      end
+    end
+
+    module RGBWriter # :nodoc:
+      def self.write px, buff
+        buff << ((px >> 24) & 0xFF) << ((px >> 16) & 0xFF) << ((px >> 8) & 0xFF)
+      end
+
+      def self.write_at buff, pos, r, g, b, _a
+        buff.setbyte(pos, r)
+        buff.setbyte(pos + 1, g)
+        buff.setbyte(pos + 2, b)
+      end
+    end
+
+    module RGBAWriter # :nodoc:
+      def self.write px, buff
+        [px].pack("N", buffer: buff)
+      end
+
+      def self.write_at buff, pos, r, g, b, a
+        buff.setbyte(pos, r)
+        buff.setbyte(pos + 1, g)
+        buff.setbyte(pos + 2, b)
+        buff.setbyte(pos + 3, a)
+      end
+    end
+
+    module FileHelper # :nodoc:
+      def self.read_uint24 fh, _
+        (fh.getbyte << 16) | (fh.getbyte << 8) | fh.getbyte
+      end
+
+      def self.read_uint32 fh, _
+        (fh.getbyte << 24) | (fh.getbyte << 16) | (fh.getbyte << 8) | fh.getbyte
+      end
+
+      def self.read fh, _, size
+        fh.read size
+      end
+
+      def self.getbyte fh, _
+        fh.getbyte
+      end
+    end
+
+    module BufferHelper # :nodoc:
+      def self.read_uint24 buf, offset
+        (buf.unpack1("C", offset: offset) << 16) |
+          buf.unpack1("n", offset: offset + 1)
+      end
+
+      def self.read_uint32 buf, offset
+        buf.unpack1("N", offset: offset)
+      end
+
+      def self.read buf, offset, size
+        buf.byteslice(offset, size)
+      end
+
+      def self.getbyte buf, offset
+        buf.getbyte offset
+      end
+    end
+
+    # Decodes a QOI image from a binary string.
+    #
+    # @param buff [String] Binary string containing QOI-encoded data.
+    # @return [Image] The decoded image.
+    # @raise [Errors::FormatError] If the data is not valid QOI format.
+    def self.from_buffer buff
+      decode buff, BufferHelper
+    end
+
+    # Decodes a QOI image from a file.
+    #
+    # @param name [String] Path to the QOI file.
+    # @return [Image] The decoded image.
+    # @raise [Errors::FormatError] If the file is not valid QOI format.
+    def self.from_file name
+      File.open(name, "rb") do |file|
+        decode file, FileHelper
+      end
+    end
+
+    # @!attribute [r] width
+    #   @return [Integer] The image width in pixels.
+
+    # @!attribute [r] height
+    #   @return [Integer] The image height in pixels.
+
+    # @!attribute [r] channels
+    #   @return [Integer] Number of channels (3 for RGB, 4 for RGBA).
+
+    # @!attribute [r] colorspace
+    #   @return [Integer] Colorspace identifier (see {Colorspace}).
+
+    attr_reader :width, :height, :channels, :colorspace
+
+    # Creates a new QOI image.
+    #
+    # @param width [Integer] Image width in pixels.
+    # @param height [Integer] Image height in pixels.
+    # @param channels [Integer] Number of channels (3 or 4).
+    # @param colorspace [Integer] Colorspace (see {Colorspace}).
+    # @param buffer [String, nil] Raw pixel data, or nil to create a blank image.
+    # @raise [Errors::BufferSizeError] If buffer size doesn't match dimensions.
+    def initialize width, height, channels, colorspace, buffer = empty_buffer(width, height, channels)
+      expected_size = width * height * channels
+      if buffer.bytesize != expected_size
+        raise Errors::BufferSizeError, "buffer size #{buffer.bytesize} does not match expected size #{expected_size} (#{width}x#{height}x#{channels})"
+      end
+      @width = width
+      @height = height
+      @channels = channels
+      @colorspace = colorspace
+      @buffer = buffer
+      @reader = channels == 3 ? RGBReader : RGBAReader
+      @writer = channels == 3 ? RGBWriter : RGBAWriter
+    end
+
+    # Encodes the image to QOI format.
+    #
+    # @return [String] Binary string containing the QOI-encoded image.
+    def encode
+      Image.encode(@width, @height, @channels, @colorspace, @buffer)
+    end
+
+    # Returns a copy of the raw pixel data.
+    #
+    # The buffer contains pixels in row-major order, with 3 bytes per pixel
+    # for RGB images or 4 bytes per pixel for RGBA images.
+    #
+    # @return [String] Copy of the pixel data buffer.
+    def buffer; @buffer.dup; end
+
+    # Gets the RGBA values of a pixel.
+    #
+    # For RGB images, the alpha value is always 255.
+    #
+    # @param x [Integer] X coordinate (0-indexed from left).
+    # @param y [Integer] Y coordinate (0-indexed from top).
+    # @return [Array<Integer>] Array of [r, g, b, a] values (0-255 each).
+    def rgba x, y
+      pos = (y * @width + x) * @channels
+      @reader.rgba @buffer, pos
+    end
+
+    # Gets the RGB values of a pixel.
+    #
+    # @param x [Integer] X coordinate (0-indexed from left).
+    # @param y [Integer] Y coordinate (0-indexed from top).
+    # @return [Array<Integer>] Array of [r, g, b] values (0-255 each).
+    def rgb x, y
+      pos = (y * @width + x) * @channels
+      @reader.rgb @buffer, pos
+    end
+
+    # Gets a pixel as a packed 32-bit integer.
+    #
+    # The format is 0xRRGGBBAA (RGBA from high to low bits).
+    # For RGB images, the alpha value is always 0xFF.
+    #
+    # @param x [Integer] X coordinate (0-indexed from left).
+    # @param y [Integer] Y coordinate (0-indexed from top).
+    # @return [Integer] Packed pixel value.
+    def pixel x, y
+      pos = (y * @width + x) * @channels
+      @reader.read @buffer, pos
+    end
+
+    # Sets a pixel's RGB values.
+    #
+    # For RGBA images, the alpha is set to 255.
+    # For RGB images, only the RGB values are stored.
+    #
+    # @param x [Integer] X coordinate (0-indexed from left).
+    # @param y [Integer] Y coordinate (0-indexed from top).
+    # @param r [Integer] Red value (0-255).
+    # @param g [Integer] Green value (0-255).
+    # @param b [Integer] Blue value (0-255).
+    # @return [void]
+    def set_rgb x, y, r, g, b
+      pos = (y * @width + x) * @channels
+      @writer.write_at @buffer, pos, r, g, b, 255
+    end
+
+    # Sets a pixel's RGBA values.
+    #
+    # For RGB images, the alpha value is ignored.
+    #
+    # @param x [Integer] X coordinate (0-indexed from left).
+    # @param y [Integer] Y coordinate (0-indexed from top).
+    # @param r [Integer] Red value (0-255).
+    # @param g [Integer] Green value (0-255).
+    # @param b [Integer] Blue value (0-255).
+    # @param a [Integer] Alpha value (0-255).
+    # @return [void]
+    def set_rgba x, y, r, g, b, a
+      pos = (y * @width + x) * @channels
+      @writer.write_at @buffer, pos, r, g, b, a
+    end
+
+    private
+
+    def empty_buffer width, height, channels
+      "\0".b * (width * height * channels)
+    end
+  end
+end

data/qoi.gemspec

@@ -0,0 +1,25 @@
+$: << File.expand_path("lib")
+
+require "qoi/version"
+
+Gem::Specification.new do |s|
+  s.name        = "qoi"
+  s.version     = QOI::VERSION
+  s.summary     = "Quite OK Image Format Implementation"
+  s.description = "Quite OK Image Format Implementation in pure Ruby"
+  s.authors     = ["Aaron Patterson"]
+  s.email       = "tenderlove@ruby-lang.org"
+  s.files       = `git ls-files -z`.split("\x0")
+  s.test_files  = s.files.grep(%r{^test/})
+  s.homepage    = "https://github.com/tenderlove/qoi"
+  s.license     = "Apache-2.0"
+
+  s.add_development_dependency 'chunky_png', '>= 1.4.0'
+  s.add_development_dependency 'minitest', '>= 5.15'
+  s.add_development_dependency 'rake', '>= 13.0'
+  s.add_development_dependency 'net-http', '>= 0.9.1'
+  s.add_development_dependency 'uri', '>= 0.11.1'
+  s.add_development_dependency 'rubyzip', '>= 3.2.2'
+
+  s.required_ruby_version = '>= 3.3.0'
+end

data/test/decode_test.rb

@@ -0,0 +1,30 @@
+require "helper"
+
+module QOI
+  class DecodeTest < Test
+    IMGS = File.join(File.dirname(__FILE__), "images", "qoi_test_images")
+
+    %w{ dice edgecase kodim10 kodim23
+        qoi_logo testcard_rgba testcard wikipedia_008 }.each do |name|
+      define_method("test_decode_#{name}_file") do
+        png = ChunkyPNG::Image.from_file(File.join(IMGS, name + ".png"))
+        buff = QOI::Image.from_file File.join(IMGS, name + ".qoi")
+        expected = buff.channels == 3 ? png.to_rgb_stream : png.to_rgba_stream
+
+        assert_equal png.width, buff.width
+        assert_equal png.height, buff.height
+        assert_equal expected, buff.buffer
+      end
+
+      define_method("test_decode_#{name}_buffer") do
+        png = ChunkyPNG::Image.from_file(File.join(IMGS, name + ".png"))
+        buff = QOI::Image.from_buffer File.binread File.join(IMGS, name + ".qoi")
+        expected = buff.channels == 3 ? png.to_rgb_stream : png.to_rgba_stream
+
+        assert_equal png.width, buff.width
+        assert_equal png.height, buff.height
+        assert_equal expected, buff.buffer
+      end
+    end
+  end
+end

data/test/encode_test.rb

@@ -0,0 +1,30 @@
+require "helper"
+
+module QOI
+  class EncodeTest < Test
+    IMGS = File.join(File.dirname(__FILE__), "images", "qoi_test_images")
+
+    %w{ dice edgecase kodim10 kodim23
+        qoi_logo testcard_rgba testcard wikipedia_008 }.each do |name|
+      define_method("test_encoding_#{name}_roundtrip") do
+        # Load the PNG and get pixel data
+        png = ChunkyPNG::Image.from_file(File.join(IMGS, name + ".png"))
+
+        # Use channels from reference QOI file
+        reference = File.binread(File.join(IMGS, name + ".qoi"))
+        channels = reference.getbyte(12)
+        original_pixels = channels == 3 ? png.to_rgb_stream : png.to_rgba_stream
+
+        # Create QOI buffer and encode it
+        img = QOI::Image.new(png.width, png.height, channels, 0, original_pixels)
+        encoded = img.encode
+
+        # Verify roundtrip: decode our encoded data and compare pixels
+        decoded = QOI::Image.from_buffer(encoded)
+        assert_equal png.width, decoded.width, "Width mismatch"
+        assert_equal png.height, decoded.height, "Height mismatch"
+        assert_equal original_pixels, decoded.buffer, "Pixel data mismatch"
+      end
+    end
+  end
+end

data/test/helper.rb

@@ -0,0 +1,8 @@
+require "minitest/autorun"
+require "chunky_png"
+require "qoi"
+
+module QOI
+  class Test < Minitest::Test
+  end
+end

data/test/image_test.rb

@@ -0,0 +1,139 @@
+require "helper"
+
+module QOI
+  class ImageTest < Test
+    IMGS = File.join(File.dirname(__FILE__), "images", "qoi_test_images")
+
+    def test_rgba_on_rgba_image
+      img = QOI::Image.from_file File.join(IMGS, "dice.qoi")
+      png = ChunkyPNG::Image.from_file(File.join(IMGS, "dice.png"))
+
+      # Test a few pixels
+      [[0, 0], [10, 10], [img.width - 1, img.height - 1]].each do |x, y|
+        expected = ChunkyPNG::Color.to_truecolor_alpha_bytes(png[x, y])
+        assert_equal expected, img.rgba(x, y), "RGBA mismatch at (#{x}, #{y})"
+      end
+    end
+
+    def test_rgb_on_rgba_image
+      img = QOI::Image.from_file File.join(IMGS, "dice.qoi")
+      png = ChunkyPNG::Image.from_file(File.join(IMGS, "dice.png"))
+
+      [[0, 0], [10, 10], [img.width - 1, img.height - 1]].each do |x, y|
+        expected = ChunkyPNG::Color.to_truecolor_bytes(png[x, y])
+        assert_equal expected, img.rgb(x, y), "RGB mismatch at (#{x}, #{y})"
+      end
+    end
+
+    def test_rgba_on_rgb_image
+      img = QOI::Image.from_file File.join(IMGS, "kodim10.qoi")
+      png = ChunkyPNG::Image.from_file(File.join(IMGS, "kodim10.png"))
+
+      [[0, 0], [10, 10], [img.width - 1, img.height - 1]].each do |x, y|
+        expected = ChunkyPNG::Color.to_truecolor_bytes(png[x, y]) + [255]
+        assert_equal expected, img.rgba(x, y), "RGBA mismatch at (#{x}, #{y})"
+      end
+    end
+
+    def test_rgb_on_rgb_image
+      img = QOI::Image.from_file File.join(IMGS, "kodim10.qoi")
+      png = ChunkyPNG::Image.from_file(File.join(IMGS, "kodim10.png"))
+
+      [[0, 0], [10, 10], [img.width - 1, img.height - 1]].each do |x, y|
+        expected = ChunkyPNG::Color.to_truecolor_bytes(png[x, y])
+        assert_equal expected, img.rgb(x, y), "RGB mismatch at (#{x}, #{y})"
+      end
+    end
+
+    def test_pixel_on_rgba_image
+      img = QOI::Image.from_file File.join(IMGS, "dice.qoi")
+      png = ChunkyPNG::Image.from_file(File.join(IMGS, "dice.png"))
+
+      [[0, 0], [10, 10], [img.width - 1, img.height - 1]].each do |x, y|
+        r, g, b, a = ChunkyPNG::Color.to_truecolor_alpha_bytes(png[x, y])
+        expected = (r << 24) | (g << 16) | (b << 8) | a
+        assert_equal expected, img.pixel(x, y), "Pixel mismatch at (#{x}, #{y})"
+      end
+    end
+
+    def test_pixel_on_rgb_image
+      img = QOI::Image.from_file File.join(IMGS, "kodim10.qoi")
+      png = ChunkyPNG::Image.from_file(File.join(IMGS, "kodim10.png"))
+
+      [[0, 0], [10, 10], [img.width - 1, img.height - 1]].each do |x, y|
+        r, g, b = ChunkyPNG::Color.to_truecolor_bytes(png[x, y])
+        expected = (r << 24) | (g << 16) | (b << 8) | 0xFF
+        assert_equal expected, img.pixel(x, y), "Pixel mismatch at (#{x}, #{y})"
+      end
+    end
+
+    def test_set_rgba_on_rgba_image
+      img = QOI::Image.new(2, 2, 4, 0)
+      img.set_rgba(0, 0, 255, 128, 64, 200)
+      img.set_rgba(1, 0, 10, 20, 30, 40)
+      img.set_rgba(0, 1, 100, 150, 200, 250)
+      img.set_rgba(1, 1, 0, 0, 0, 255)
+
+      assert_equal [255, 128, 64, 200], img.rgba(0, 0)
+      assert_equal [10, 20, 30, 40], img.rgba(1, 0)
+      assert_equal [100, 150, 200, 250], img.rgba(0, 1)
+      assert_equal [0, 0, 0, 255], img.rgba(1, 1)
+    end
+
+    def test_set_rgb_on_rgba_image
+      img = QOI::Image.new(2, 2, 4, 0)
+      img.set_rgb(0, 0, 255, 128, 64)
+      img.set_rgb(1, 1, 10, 20, 30)
+
+      assert_equal [255, 128, 64], img.rgb(0, 0)
+      assert_equal [10, 20, 30], img.rgb(1, 1)
+      # Alpha should be set to 255 by set_rgb
+      assert_equal [255, 128, 64, 255], img.rgba(0, 0)
+    end
+
+    def test_set_rgba_on_rgb_image
+      img = QOI::Image.new(2, 2, 3, 0)
+      img.set_rgba(0, 0, 255, 128, 64, 200)
+      img.set_rgba(1, 1, 10, 20, 30, 40)
+
+      # Alpha is ignored for RGB images
+      assert_equal [255, 128, 64], img.rgb(0, 0)
+      assert_equal [10, 20, 30], img.rgb(1, 1)
+    end
+
+    def test_set_rgb_on_rgb_image
+      img = QOI::Image.new(2, 2, 3, 0)
+      img.set_rgb(0, 0, 255, 128, 64)
+      img.set_rgb(1, 0, 10, 20, 30)
+      img.set_rgb(0, 1, 100, 150, 200)
+      img.set_rgb(1, 1, 0, 0, 0)
+
+      assert_equal [255, 128, 64], img.rgb(0, 0)
+      assert_equal [10, 20, 30], img.rgb(1, 0)
+      assert_equal [100, 150, 200], img.rgb(0, 1)
+      assert_equal [0, 0, 0], img.rgb(1, 1)
+    end
+
+    def test_buffer_size_mismatch_raises_error
+      # Buffer too small
+      err = assert_raises(QOI::Errors::BufferSizeError) do
+        QOI::Image.new(10, 10, 4, 0, "\x00" * 100)
+      end
+      assert_match(/buffer size 100 does not match expected size 400/, err.message)
+
+      # Buffer too large
+      err = assert_raises(QOI::Errors::BufferSizeError) do
+        QOI::Image.new(2, 2, 3, 0, "\x00" * 20)
+      end
+      assert_match(/buffer size 20 does not match expected size 12/, err.message)
+    end
+
+    def test_buffer_size_correct_does_not_raise
+      # Exact size should work - no exception raised
+      img1 = QOI::Image.new(10, 10, 4, 0, "\x00" * 400)
+      img2 = QOI::Image.new(2, 2, 3, 0, "\x00" * 12)
+      assert_equal 10, img1.width
+      assert_equal 2, img2.width
+    end
+  end
+end

metadata

@@ -0,0 +1,142 @@
+--- !ruby/object:Gem::Specification
+name: qoi
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Aaron Patterson
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: chunky_png
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.0
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.15'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.15'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: net-http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.1
+- !ruby/object:Gem::Dependency
+  name: uri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.11.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.11.1
+- !ruby/object:Gem::Dependency
+  name: rubyzip
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.2.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.2.2
+description: Quite OK Image Format Implementation in pure Ruby
+email: tenderlove@ruby-lang.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/workflows/ci.yml"
+- ".github/workflows/release.yml"
+- ".gitignore"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/qoi.rb
+- lib/qoi/version.rb
+- qoi.gemspec
+- test/decode_test.rb
+- test/encode_test.rb
+- test/helper.rb
+- test/image_test.rb
+homepage: https://github.com/tenderlove/qoi
+licenses:
+- Apache-2.0
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.1.0.dev
+specification_version: 4
+summary: Quite OK Image Format Implementation
+test_files:
+- test/decode_test.rb
+- test/encode_test.rb
+- test/helper.rb
+- test/image_test.rb