jxl 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: fac5dc523300bacccf3012d8333be15c4aeb0b78fca35584851c63bdaf6e405e
+  data.tar.gz: 69c4b42c0b664e2971f2664e07ba1b762798918aa265a4193cd2559fab60b45d
+SHA512:
+  metadata.gz: 183e914771ed5c01c309d205bf16882b8b201382b3f2ac869ba2c66a6550d7c7e7bc12489c50c79f0123fec2247d8c9a33317050a4761dcc84f2de3af64e9525
+  data.tar.gz: 7d212e9bff85928366f697921c27bca209bf58563a2f50a08bf071eec21b01ebe79488434881c5ef6445329cb22e07a097e9834b4e0adaa1d44f391406d88f2c

data/.rubocop.yml

@@ -0,0 +1,93 @@
+AllCops:
+  NewCops: enable
+  SuggestExtensions: false
+  TargetRubyVersion: 3.2
+
+Gemspec/RequireMFA:
+  Enabled: true
+
+Metrics/BlockLength:
+  Exclude:
+    - "spec/**/*"
+
+Metrics/MethodLength:
+  Max: 50
+  Exclude:
+    - "lib/jxl/modular/decoder.rb"
+
+Metrics/ClassLength:
+  Max: 150
+  Exclude:
+    - "lib/jxl/entropy/decoder.rb"
+
+Metrics/ModuleLength:
+  Max: 150
+  Exclude:
+    - "lib/jxl/headers/frame_header.rb"
+    - "lib/jxl/modular/decoder.rb"
+    - "lib/jxl/modular/transform.rb"
+    - "lib/jxl/vardct/*.rb"
+
+Metrics/AbcSize:
+  Max: 30
+  Exclude:
+    - "lib/jxl/codestream/reader.rb"
+    - "lib/jxl/container/parser.rb"
+    - "lib/jxl/headers/frame_header.rb"
+    - "lib/jxl/modular/decoder.rb"
+    - "lib/jxl/modular/predictor.rb"
+    - "lib/jxl/modular/transform.rb"
+    - "lib/jxl/vardct/*.rb"
+    - "lib/jxl/color/*.rb"
+    - "lib/jxl/filter/*.rb"
+    - "lib/jxl/features/*.rb"
+    - "lib/jxl/render/*.rb"
+
+Metrics/CyclomaticComplexity:
+  Exclude:
+    - "lib/jxl/color/*.rb"
+    - "lib/jxl/features/*.rb"
+    - "lib/jxl/render/*.rb"
+    - "lib/jxl/container/parser.rb"
+    - "lib/jxl/headers/frame_header.rb"
+    - "lib/jxl/modular/decoder.rb"
+    - "lib/jxl/modular/predictor.rb"
+    - "lib/jxl/modular/transform.rb"
+    - "lib/jxl/vardct/*.rb"
+
+Metrics/PerceivedComplexity:
+  Exclude:
+    - "lib/jxl.rb"
+    - "lib/jxl/color/*.rb"
+    - "lib/jxl/features/*.rb"
+    - "lib/jxl/container/parser.rb"
+    - "lib/jxl/headers/frame_header.rb"
+    - "lib/jxl/modular/decoder.rb"
+    - "lib/jxl/modular/predictor.rb"
+    - "lib/jxl/modular/transform.rb"
+    - "lib/jxl/vardct/*.rb"
+
+Metrics/ParameterLists:
+  Exclude:
+    - "lib/jxl/filter/*.rb"
+    - "lib/jxl/features/*.rb"
+    - "lib/jxl/render/*.rb"
+    - "lib/jxl/modular/decoder.rb"
+    - "lib/jxl/modular/predictor.rb"
+    - "lib/jxl/modular/stream.rb"
+    - "lib/jxl/vardct/*.rb"
+
+Style/StringConcatenation:
+  Enabled: false
+
+Naming/MethodParameterName:
+  Enabled: false
+
+Naming/PredicateMethod:
+  Enabled: false
+
+Style/Documentation:
+  Enabled: false
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Yudai Yudai
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,90 @@
+# jxl
+
+`jxl` is a JPEG XL decoder and lossless Modular encoder written in Ruby without native extensions.
+
+## Installation
+
+```sh
+bundle add jxl
+```
+
+Ruby 3.2 or newer is required. YJIT is recommended for large images.
+
+## Decode
+
+```ruby
+require "jxl"
+
+image = JXL.decode(File.binread("input.jxl"), max_pixels: 100_000_000)
+File.binwrite("output.png", JXL::IO::PNG.dump(image))
+```
+
+`JXL.decode` accepts `pixel_format`, `color_space`, `desired_scale`, `max_pixels`, `max_memory`, `strict`,
+`apply_orientation`, and `render_spot_colors`. Packed pixel data is available through `Image#to_rgba8`,
+`#to_rgba16`, and `#to_float`; `pixel_format` validates the requested format for API compatibility.
+Output writers support PNG, PPM/PGM, PAM, PFM, grayscale PGX, and multi-frame NPY.
+
+For incremental input, use `JXL::Decoder#feed`, drain `#next_event`, and call `#finish` at end of input.
+
+```ruby
+decoder = JXL::Decoder.new.subscribe(:basic_info, :frame, :full_image)
+File.open("input.jxl", "rb") { |file| decoder.feed(chunk) while (chunk = file.read(65_536)) }
+decoder.finish
+loop do
+  event = decoder.next_event
+  break if event.nil? || event.type == :full_image
+end
+```
+
+The command-line decoder is also available:
+
+```sh
+djxl input.jxl output.png
+```
+
+## Encode
+
+The encoder writes lossless RGB Modular codestreams using RCT6, a Gradient predictor, and prefix entropy coding.
+
+```ruby
+bytes = JXL.encode(image, bits_per_sample: 8)
+File.binwrite("output.jxl", bytes)
+```
+
+The CLI accepts binary PPM/PGM and non-interlaced 8-bit PNG input:
+
+```sh
+cjxl input.png output.jxl
+```
+
+## Development
+
+```sh
+bundle exec rake
+bundle exec rake fuzz:truncate
+bundle exec rake bench
+```
+
+Set `JXL_CONFORMANCE_CASES` to the conformance suite's `main_level5.txt` to enable full reference comparisons.
+After running the official conformance runner with `--results`, print its measured results with:
+
+```sh
+JXL_CONFORMANCE_RESULTS=results.json bundle exec rake conformance:report
+```
+
+## Support
+
+Version 1.0 decodes Level 5 raw codestreams and `jxlc`/`jxlp` containers, including Modular and VarDCT,
+progressive frames, animation and blending, all transform strategies, restoration filters, image features,
+extra channels, orientation, standardized transfer functions, and embedded ICC profiles. The lossless encoder
+writes RGB Modular codestreams that round-trip through this gem and libjxl.
+
+The current upstream Level 5 conformance manifest has 23 cases; all 23 pass the official runner in lax pixel
+mode. JPEG bitstream reconstruction from `jbrd` and Brotli-compressed `brob` metadata are optional next-version
+features. Preview rendering is not exposed, the event decoder buffers the complete compressed image before
+emitting frame pixels, and `strict: false` only replaces non-finite decoded samples; structural corruption still
+raises `JXL::Error`.
+
+## License
+
+MIT

data/Rakefile

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require "rubocop/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]
+
+namespace :conformance do
+  desc "Print the JPEG XL conformance progress table"
+  task :report do
+    ruby "tools/conformance_report.rb"
+  end
+end
+
+namespace :fuzz do
+  %i[truncate bitflip box].each do |mode|
+    desc "Run the #{mode} decoder fuzzer"
+    task mode do
+      ruby "tools/fuzz.rb", mode.to_s
+    end
+  end
+end
+
+desc "Benchmark the configured JPEG XL corpus"
+task :bench do
+  ruby "tools/bench.rb"
+end

data/docs/adr/0001-buffer-representation.md

@@ -0,0 +1,12 @@
+# ADR 0001: Image buffer representation
+
+## Decision
+
+Store each image plane in one row-major Ruby `Array`, wrapped by `JXL::Plane`.
+The stride equals the width and no row padding is used.
+
+## Rationale
+
+Flat arrays keep neighbour access simple for Modular prediction and avoid the
+pointer chasing of nested arrays. Packed strings save memory but add conversion
+cost and obscure integer and floating-point handling.

data/docs/bench_history.md

@@ -0,0 +1,11 @@
+# Benchmark history
+
+Apple Silicon, Ruby 4.0.0 with YJIT. Times are best-effort local measurements.
+
+| Date | Case | Seconds | MP/s | Change |
+|---|---|---:|---:|---|
+| 2026-08-28 | alpha_triangles | 12.797 | 0.082 | Baseline |
+| 2026-08-28 | grayscale | 1.258 | 0.032 | Baseline |
+| 2026-08-28 | lz77_flower | 3.312 | 0.061 | Baseline |
+| 2026-08-28 | alpha_triangles | 5.292 | 0.198 | Allocation-free neighbour lookup |
+| 2026-08-28 | grayscale_public_university | 141.070 | 0.033 | Single-pass grayscale restoration filters |

data/docs/spec_map.md

@@ -0,0 +1,16 @@
+# JPEG XL implementation map
+
+| Area | Implementation |
+|---|---|
+| Container and boxes | `lib/jxl/container` |
+| Headers and TOC | `lib/jxl/headers`, `lib/jxl/frame/toc.rb` |
+| Prefix, ANS, HybridUint, LZ77 | `lib/jxl/entropy` |
+| Modular and transforms | `lib/jxl/modular` |
+| VarDCT and all transform strategies | `lib/jxl/vardct`, `lib/jxl/dct.rb` |
+| Restoration and image features | `lib/jxl/filter`, `lib/jxl/features` |
+| Colour and ICC | `lib/jxl/color` |
+| Animation, blending, orientation | `lib/jxl/render`, `lib/jxl.rb` |
+| Lossless encoder | `lib/jxl/encoder.rb`, `lib/jxl/entropy/encoder.rb` |
+| Streaming API | `lib/jxl/decoder.rb` |
+
+JPEG bitstream reconstruction from `jbrd` is outside the initial codec scope.

data/exe/cjxl

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "optparse"
+require "jxl"
+
+options = { bits_per_sample: 8 }
+OptionParser.new do |parser|
+  parser.banner = "usage: cjxl INPUT OUTPUT [options]"
+  parser.on("--bits-per-sample N", Integer) { options[:bits_per_sample] = _1 }
+end.parse!
+abort "usage: cjxl INPUT OUTPUT [options]" unless ARGV.length == 2
+
+input, output = ARGV
+data = File.binread(input)
+image = case File.extname(input).downcase
+        when ".ppm", ".pgm", ".pnm" then JXL::IO::PPM.load(data)
+        when ".png" then JXL::IO::PNG.load(data)
+        else abort "unsupported input extension: #{File.extname(input)}"
+        end
+File.binwrite(output, JXL.encode(image, **options))

data/exe/djxl

@@ -0,0 +1,66 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "optparse"
+require "json"
+require "jxl"
+
+options = { frame: nil, max_pixels: 100_000_000, render_spot_colors: true }
+OptionParser.new do |parser|
+  parser.banner = "usage: djxl INPUT OUTPUT [options]"
+  parser.on("--frame N", Integer) { options[:frame] = _1 }
+  parser.on("--max-pixels N", Integer) { options[:max_pixels] = _1 }
+  parser.on("--icc_out FILE", "--icc-out FILE") { options[:icc_out] = _1 }
+  parser.on("--orig_icc_out FILE", "--orig-icc-out FILE") { options[:orig_icc_out] = _1 }
+  parser.on("--metadata_out FILE", "--metadata-out FILE") { options[:metadata_out] = _1 }
+  parser.on("--norender_spotcolors") { options[:render_spot_colors] = false }
+end.parse!
+abort "usage: djxl INPUT OUTPUT [options]" unless ARGV.length == 2
+
+input, output = ARGV
+data = File.binread(input)
+image = JXL.decode(data, max_pixels: options[:max_pixels], render_spot_colors: options[:render_spot_colors])
+if options[:frame]
+  frame = image.frames.fetch(options[:frame])
+  image = image.with(channels: frame.planes, frames: [frame])
+end
+
+File.binwrite(options[:icc_out], image.icc_profile) if options[:icc_out]
+if options[:orig_icc_out]
+  original = JXL::Codestream::Reader.new(data, max_pixels: options[:max_pixels]).read_headers.icc_profile
+  File.binwrite(options[:orig_icc_out], original || image.icc_profile)
+end
+if options[:metadata_out]
+  metadata = image.metadata
+  depths = [metadata.bit_depth] + metadata.extra_channels.map(&:bit_depth)
+  extra_types = %w[Alpha Depth SpotColor SelectionMask Black CFA Thermal Optional]
+  frames = image.frames.map do |frame|
+    values = { name: frame.name }
+    if metadata.animation
+      values[:duration] = frame.duration.fdiv(metadata.animation.ticks_numerator) *
+                          metadata.animation.ticks_denominator
+    end
+    values
+  end
+  descriptor = {
+    frames:,
+    intensity_target: metadata.tone_mapping.intensity_target,
+    min_nits: metadata.tone_mapping.min_nits,
+    relative_to_max_display: metadata.tone_mapping.relative_to_max_display ? 1 : 0,
+    linear_below: metadata.tone_mapping.linear_below,
+    extra_channel_type: metadata.extra_channels.map { |channel| extra_types.fetch(channel.type, "Unknown") },
+    bits_per_sample: depths.map(&:bits_per_sample),
+    exp_bits_per_sample: depths.map(&:exponent_bits)
+  }
+  File.write(options[:metadata_out], JSON.generate(descriptor))
+end
+
+case File.extname(output).downcase
+when ".ppm", ".pgm" then File.binwrite(output, JXL::IO::PPM.dump(image))
+when ".pam" then File.binwrite(output, JXL::IO::PAM.dump(image))
+when ".pfm" then File.binwrite(output, JXL::IO::PFM.dump(image))
+when ".pgx" then File.binwrite(output, JXL::IO::PGX.dump(image))
+when ".png" then File.binwrite(output, JXL::IO::PNG.dump(image))
+when ".npy" then JXL::IO::NPY.dump_image(output, image)
+else abort "unsupported output extension: #{File.extname(output)}"
+end

data/exe/jxlinfo

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "optparse"
+require "jxl"
+
+verbose = false
+OptionParser.new do |options|
+  options.banner = "usage: jxlinfo [--verbose] FILE"
+  options.on("-v", "--verbose") { verbose = true }
+end.parse!
+abort "missing JPEG XL file" unless ARGV.one?
+
+info = JXL.info(File.binread(ARGV.first), max_pixels: 1_000_000_000)
+metadata = info.metadata
+depth = metadata.bit_depth
+kind = metadata.animation ? "animation" : "image"
+sample = depth.floating_point ? "#{depth.bits_per_sample}-bit float" : "#{depth.bits_per_sample}-bit"
+channels = metadata.colour_encoding.colour_space == 1 ? "Grayscale" : "RGB"
+channels += metadata.extra_channels.any? { |channel| channel.type.zero? } ? "+Alpha" : ""
+
+puts "JPEG XL file format container (ISO/IEC 18181-2)" if info.container.each_box.any?
+puts "JPEG bitstream reconstruction data available" if info.container.metadata[:jpeg_reconstruction]
+puts "JPEG XL #{kind}, #{info.width}x#{info.height}, (possibly) lossless, #{sample} #{channels}"
+
+if metadata.colour_encoding.want_icc
+  puts "ICC profile present" if verbose
+else
+  colour_spaces = %w[RGB Grayscale XYB Unknown]
+  puts "Color space: #{colour_spaces.fetch(metadata.colour_encoding.colour_space, 'Unknown')}"
+end

data/lib/jxl/basic_info.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module JXL
+  BasicInfo = Data.define(:width, :height, :metadata, :container, :bits_consumed) do
+    def self.read(data, max_pixels: 100_000_000)
+      container = Container::Parser.new(data, ignore_brob: true)
+      stream = container.codestream
+      raise SignatureError, "invalid codestream signature" unless stream.start_with?(Container::Signature::CODESTREAM)
+
+      reader = Bit::Reader.new(stream, 2)
+      size = Headers::SizeHeader.read(reader, max_pixels:)
+      metadata = Headers::ImageMetadata.read(reader, max_pixels:)
+      new(width: size.width, height: size.height, metadata:, container:, bits_consumed: reader.bits_read)
+    end
+  end
+end

data/lib/jxl/bit/field.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module JXL
+  module Bit
+    module Field
+      Distribution = Data.define(:bits, :offset, :value)
+
+      module_function
+
+      def val(value) = Distribution.new(bits: nil, offset: nil, value:)
+      def bits(count) = bits_offset(count, 0)
+      def bits_offset(count, offset) = Distribution.new(bits: count, offset:, value: nil)
+
+      def u32(reader, *distributions)
+        raise ArgumentError, "U32 requires four distributions" unless distributions.length == 4
+
+        distribution = distributions.fetch(reader.read(2))
+        return distribution.value unless distribution.value.nil?
+
+        reader.read(distribution.bits) + distribution.offset
+      end
+
+      def write_u32(writer, value, *distributions)
+        raise ArgumentError, "U32 requires four distributions" unless distributions.length == 4
+
+        selector = distributions.index do |distribution|
+          distribution.value == value || (distribution.bits && value >= distribution.offset &&
+                                           (value - distribution.offset).bit_length <= distribution.bits)
+        end
+        raise ArgumentError, "value is not representable by U32" unless selector
+
+        distribution = distributions[selector]
+        writer.write(2, selector)
+        writer.write(distribution.bits, value - distribution.offset) if distribution.bits
+        writer
+      end
+
+      def u64(reader)
+        case reader.read(2)
+        when 0 then 0
+        when 1 then reader.read(4) + 1
+        when 2 then reader.read(8) + 17
+        else read_large_u64(reader)
+        end
+      end
+
+      def write_u64(writer, value)
+        case value
+        when 0 then writer.write(2, 0)
+        when 1..16 then writer.write(2, 1).write(4, value - 1)
+        when 17..272 then writer.write(2, 2).write(8, value - 17)
+        else write_large_u64(writer, value)
+        end
+      end
+
+      def write_large_u64(writer, value)
+        raise ArgumentError, "U64 is out of range" unless value.between?(0, (1 << 64) - 1)
+
+        writer.write(2, 3).write(12, value & 0xFFF)
+        shift = 12
+        loop do
+          bits = shift == 60 ? 4 : 8
+          more = (value >> shift).positive?
+          writer.write(1, more ? 1 : 0)
+          break unless more
+
+          writer.write(bits, (value >> shift) & ((1 << bits) - 1))
+          break if shift == 60
+
+          shift += 8
+        end
+        writer
+      end
+      private_class_method :write_large_u64
+
+      def f16(reader)
+        bits = reader.read(16)
+        sign = bits[15].zero? ? 1.0 : -1.0
+        exponent = (bits >> 10) & 0x1F
+        mantissa = bits & 0x3FF
+        raise FormatError, "F16 infinity or NaN" if exponent == 0x1F
+
+        magnitude = if exponent.zero?
+                      mantissa * (2.0**-24)
+                    else
+                      (1024 + mantissa) * (2.0**(exponent - 25))
+                    end
+        sign * magnitude
+      end
+
+      def enum(reader) = u32(reader, val(0), val(1), bits_offset(4, 2), bits_offset(6, 18))
+      def read_bool(reader) = !reader.read(1).zero?
+
+      def string(reader)
+        length = u32(reader, val(0), bits(4), bits_offset(5, 16), bits_offset(10, 48))
+        Array.new(length) { reader.read(8) }.pack("C*").force_encoding(Encoding::UTF_8)
+      end
+
+      def skip_extensions(reader)
+        extensions = u64(reader)
+        lengths = []
+        bit = 0
+        until extensions.zero?
+          lengths << u64(reader) unless extensions[bit].zero?
+          extensions &= ~(1 << bit)
+          bit += 1
+        end
+        reader.skip(lengths.sum)
+      end
+
+      def read_large_u64(reader)
+        value = reader.read(12)
+        shift = 12
+        until reader.read(1).zero?
+          bit_count = shift == 60 ? 4 : 8
+          value |= reader.read(bit_count) << shift
+          break if shift == 60
+
+          shift += 8
+        end
+        value
+      end
+      private_class_method :read_large_u64
+    end
+  end
+end

data/lib/jxl/bit/reader.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module JXL
+  module Bit
+    class Reader
+      MAX_BITS = 56
+
+      attr_reader :bits_read
+
+      def initialize(data, position = 0)
+        unless position.is_a?(Integer) && position.between?(0, data.bytesize)
+          raise ArgumentError, "invalid byte position"
+        end
+
+        @data = data.b
+        @byte_position = position
+        @buffer = 0
+        @buffered_bits = 0
+        @bits_read = 0
+        @overrun = false
+      end
+
+      def read(bits)
+        raise ArgumentError, "bit count must be between 0 and #{MAX_BITS}" unless bits.between?(0, MAX_BITS)
+
+        refill while @buffered_bits < bits
+        value = @buffer & ((1 << bits) - 1)
+        @buffer >>= bits
+        @buffered_bits -= bits
+        @bits_read += bits
+        Trace.br(bits, value, @bits_read)
+        value
+      end
+
+      def peek(bits)
+        raise ArgumentError, "bit count must be between 0 and #{MAX_BITS}" unless bits.between?(0, MAX_BITS)
+
+        refill while @buffered_bits < bits
+        @buffer & ((1 << bits) - 1)
+      end
+
+      def skip(bits)
+        while bits > MAX_BITS
+          read(MAX_BITS)
+          bits -= MAX_BITS
+        end
+        read(bits)
+        nil
+      end
+
+      def zero_pad_to_byte
+        padding = (-@bits_read) & 7
+        raise CorruptError, "non-zero padding bits" unless read(padding).zero?
+      end
+
+      def byte_position = @bits_read.div(8)
+      def overrun? = @overrun
+
+      def close!
+        raise TruncatedError, "bitstream ended early" if overrun?
+
+        nil
+      end
+
+      private
+
+      def refill
+        if @byte_position < @data.bytesize
+          @buffer |= @data.getbyte(@byte_position) << @buffered_bits
+          @byte_position += 1
+        else
+          @overrun = true
+        end
+        @buffered_bits += 8
+      end
+    end
+  end
+end

data/lib/jxl/bit/writer.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module JXL
+  module Bit
+    class Writer
+      attr_reader :bits_written
+
+      def initialize
+        @bytes = +"".b
+        @buffer = 0
+        @count = 0
+        @bits_written = 0
+      end
+
+      def write(count, value)
+        raise ArgumentError, "invalid bit count" unless count.between?(0, 64)
+        raise ArgumentError, "value does not fit" if value.negative? || value.bit_length > count
+
+        @buffer |= value << @count
+        @count += count
+        @bits_written += count
+        flush_bytes
+        self
+      end
+
+      def align
+        write((-@count) & 7, 0)
+      end
+
+      def bytes
+        align
+        @bytes.dup
+      end
+
+      private
+
+      def flush_bytes
+        while @count >= 8
+          @bytes << (@buffer & 0xFF)
+          @buffer >>= 8
+          @count -= 8
+        end
+      end
+    end
+  end
+end