vorbis 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 51ab935f6596d5bcc9629adcf457ad8920827419c2c777879afbc2704988114f
+  data.tar.gz: 24969f2e03d1ae9cbd7a72aaaf614c100ad87b69d3a283977794ca6defb7b994
+SHA512:
+  metadata.gz: 6ff9ac4e6a9eea530ba7182e365a3dc3bf2a638653cef18c132cd2895bbad7fd325ba59b7497f9617c6893eed1a3f1f93d9e2e3b68cb094da0decf689be06c62
+  data.tar.gz: 22279394f5b9fc644b0342537a29ff7dc12e65f00674b6538b7b010e396704d1684e375e6c2ffe568fe3d1e5b51bfabd71a3d0aa26666902f93073f5b7525868

data/CHANGELOG.md

@@ -0,0 +1,11 @@
+# Changelog
+
+All notable changes to this project are documented in this file.
+
+The format is based on Keep a Changelog and this project follows Semantic Versioning.
+
+## [Unreleased]
+
+## 0.1.0 (2026-02-28)
+
+- Initial release.

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Yudai Takada
+
+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,118 @@
+# vorbis-ruby
+
+Ruby FFI bindings for libvorbis and libvorbisenc. Provides Vorbis audio codec encoding functionality.
+
+## Installation
+
+### System Requirements
+
+libvorbis and libvorbisenc must be installed on your system.
+
+macOS:
+
+```bash
+brew install libvorbis
+```
+
+Debian / Ubuntu:
+
+```bash
+sudo apt-get install libvorbis-dev
+```
+
+Fedora / RHEL:
+
+```bash
+sudo dnf install libvorbis-devel
+```
+
+### Gem Installation
+
+Add to your Gemfile:
+
+```ruby
+gem "vorbis-ruby"
+```
+
+Or install directly:
+
+```bash
+gem install vorbis-ruby
+```
+
+## Usage
+
+```ruby
+require "vorbis"
+
+File.open("output.ogg", "wb") do |f|
+  encoder = Vorbis::Encoder.new(
+    channels: 2,
+    rate: 44100,
+    quality: 0.4,
+    comments: { "ARTIST" => "Test", "TITLE" => "Hello" }
+  )
+
+  encoder.write_headers { |data| f.write(data) }
+
+  # PCM data as per-channel float arrays (-1.0 to 1.0)
+  samples = [Array.new(1024, 0.0), Array.new(1024, 0.0)]
+  encoder.encode(samples) { |data| f.write(data) }
+
+  encoder.finish { |data| f.write(data) }
+  encoder.close
+end
+```
+
+## API Reference
+
+### `Vorbis::Encoder`
+
+High-level encoder that manages all Vorbis resources internally.
+
+- `initialize(channels:, rate:, quality: 0.4, comments: {})` — Create encoder with VBR quality (-0.1 to 1.0)
+- `write_headers { |data| }` — Yield OGG header pages
+- `encode(samples) { |data| }` — Encode PCM samples (array of per-channel float arrays) and yield OGG pages
+- `finish { |data| }` — Signal end-of-stream and yield remaining OGG pages
+- `close` — Release all resources
+
+### `Vorbis::Info`
+
+Low-level wrapper for `vorbis_info`.
+
+- `encode_init_vbr(channels:, rate:, quality:)` — Set up VBR encoding
+- `encode_init(channels:, rate:, nominal_bitrate:, max_bitrate: -1, min_bitrate: -1)` — Set up CBR/ABR encoding
+- `channels`, `rate`, `bitrate_nominal` — Accessors
+- `clear` — Release resources
+
+### `Vorbis::Comment`
+
+Low-level wrapper for `vorbis_comment`.
+
+- `add_tag(tag, value)` — Add a comment tag
+- `query(tag, index = 0)` — Query a tag value
+- `query_count(tag)` — Count tags with a given name
+- `vendor` — Get the vendor string
+- `clear` — Release resources
+
+### `Vorbis::DspState`
+
+Low-level wrapper for `vorbis_dsp_state`.
+
+- `headerout(comment)` — Generate 3 header packets
+- `analysis_buffer(samples)` — Get per-channel write buffers
+- `wrote(samples)` — Notify samples written (0 for EOS)
+- `clear` — Release resources
+
+### `Vorbis::Block`
+
+Low-level wrapper for `vorbis_block`.
+
+- `blockout` — Extract a block from DSP state
+- `analysis_and_addblock` — Analyze block and add to bitrate management
+- `flush_packet` — Flush a packet from bitrate management
+- `clear` — Release resources
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/lib/vorbis/block.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Vorbis
+  class Block
+    include Clearable
+
+    attr_reader :native
+
+    def initialize(dsp_state)
+      @dsp_state = dsp_state
+      @ptr = FFI::MemoryPointer.new(Native::VorbisBlock.size)
+      @native = Native::VorbisBlock.new(@ptr)
+      result = Native.vorbis_block_init(dsp_state.native, @ptr)
+      raise InitError, "vorbis_block_init failed with status #{result}" unless result == 0
+
+      @pkt_ptr = FFI::MemoryPointer.new(Ogg::Native::OggPacket.size)
+      setup_clearable(Native.method(:vorbis_block_clear))
+    end
+
+    def blockout
+      result = Native.vorbis_analysis_blockout(@dsp_state.native, @ptr)
+      result == 1
+    end
+
+    def analysis_and_addblock
+      result = Native.vorbis_analysis(@ptr, nil)
+      raise EncoderError, "vorbis_analysis failed with status #{result}" unless result == 0
+
+      result = Native.vorbis_bitrate_addblock(@ptr)
+      raise EncoderError, "vorbis_bitrate_addblock failed with status #{result}" unless result == 0
+    end
+
+    def flush_packet
+      result = Native.vorbis_bitrate_flushpacket(@dsp_state.native, @pkt_ptr)
+      return nil unless result == 1
+
+      Native.packet_from_native(@pkt_ptr)
+    end
+  end
+end

data/lib/vorbis/clearable.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Vorbis
+  module Clearable
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def finalizer_for(ptr, clear_state, clear_fn)
+        proc { clear_fn.call(ptr) unless clear_state[0] }
+      end
+    end
+
+    def setup_clearable(clear_fn)
+      @clear_state = [false]
+      @_native_clear = clear_fn
+      ObjectSpace.define_finalizer(self, self.class.finalizer_for(@ptr, @clear_state, clear_fn))
+    end
+
+    def clear
+      return if cleared?
+
+      @_native_clear.call(@ptr)
+      @clear_state[0] = true
+    end
+
+    def cleared?
+      @clear_state[0]
+    end
+  end
+end

data/lib/vorbis/comment.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Vorbis
+  class Comment
+    include Clearable
+
+    attr_reader :native
+
+    def initialize
+      @ptr = FFI::MemoryPointer.new(Native::VorbisComment.size)
+      @native = Native::VorbisComment.new(@ptr)
+      Native.vorbis_comment_init(@ptr)
+      setup_clearable(Native.method(:vorbis_comment_clear))
+    end
+
+    def add_tag(tag, value)
+      Native.vorbis_comment_add_tag(@ptr, tag, value)
+    end
+
+    def query(tag, index = 0)
+      result = Native.vorbis_comment_query(@ptr, tag, index)
+      result.null? ? nil : result.read_string
+    end
+
+    def query_count(tag)
+      Native.vorbis_comment_query_count(@ptr, tag)
+    end
+
+    def vendor
+      vendor_ptr = @native[:vendor]
+      return nil if vendor_ptr.null?
+
+      vendor_ptr.read_string
+    end
+  end
+end

data/lib/vorbis/dsp_state.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Vorbis
+  class DspState
+    include Clearable
+
+    attr_reader :native
+
+    def initialize(info)
+      @info = info
+      @ptr = FFI::MemoryPointer.new(Native::VorbisDspState.size)
+      @native = Native::VorbisDspState.new(@ptr)
+      result = Native.vorbis_analysis_init(@ptr, info.native)
+      raise InitError, "vorbis_analysis_init failed with status #{result}" unless result == 0
+
+      setup_clearable(Native.method(:vorbis_dsp_clear))
+    end
+
+    def headerout(comment)
+      op_ptr = FFI::MemoryPointer.new(Ogg::Native::OggPacket.size)
+      op_comm_ptr = FFI::MemoryPointer.new(Ogg::Native::OggPacket.size)
+      op_code_ptr = FFI::MemoryPointer.new(Ogg::Native::OggPacket.size)
+
+      result = Native.vorbis_analysis_headerout(@ptr, comment.native, op_ptr, op_comm_ptr, op_code_ptr)
+      raise EncoderError, "vorbis_analysis_headerout failed with status #{result}" unless result == 0
+
+      [op_ptr, op_comm_ptr, op_code_ptr].map { |pkt_ptr| Native.packet_from_native(pkt_ptr) }
+    end
+
+    def analysis_buffer(samples)
+      buffer_ptr = Native.vorbis_analysis_buffer(@ptr, samples)
+      buffer_ptr.read_array_of_pointer(@info.channels)
+    end
+
+    def wrote(samples)
+      result = Native.vorbis_analysis_wrote(@ptr, samples)
+      raise EncoderError, "vorbis_analysis_wrote failed with status #{result}" unless result == 0
+    end
+  end
+end

data/lib/vorbis/encoder.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module Vorbis
+  class Encoder
+    def initialize(channels:, rate:, quality: 0.4, comments: {})
+      @closed = false
+
+      begin
+        @info = Vorbis::Info.new
+        @info.encode_init_vbr(channels: channels, rate: rate, quality: quality)
+
+        @comment = Vorbis::Comment.new
+        comments.each { |tag, value| @comment.add_tag(tag.to_s, value.to_s) }
+
+        @dsp_state = Vorbis::DspState.new(@info)
+        @block = Vorbis::Block.new(@dsp_state)
+        @stream = Ogg::StreamState.new(rand(0xFFFFFF))
+      rescue StandardError
+        close
+        raise
+      end
+    end
+
+    def write_headers
+      ensure_open!
+
+      packets = @dsp_state.headerout(@comment)
+      packets.each { |pkt| @stream.packetin(pkt) }
+
+      while (page = @stream.flush)
+        yield page.to_s
+      end
+    end
+
+    def encode(samples)
+      ensure_open!
+      validate_samples!(samples)
+
+      num_samples = samples.first.size
+      return if num_samples.zero?
+
+      buffer = @dsp_state.analysis_buffer(num_samples)
+
+      samples.each_with_index do |channel_data, ch|
+        buffer[ch].write_array_of_float(channel_data)
+      end
+
+      @dsp_state.wrote(num_samples)
+      flush_blocks { |data| yield data }
+    end
+
+    def finish
+      ensure_open!
+
+      @dsp_state.wrote(0)
+      flush_blocks { |data| yield data }
+    end
+
+    def close
+      return if @closed
+
+      @block&.clear
+      @dsp_state&.clear
+      @comment&.clear
+      @info&.clear
+      @stream&.clear
+    ensure
+      @closed = true
+    end
+
+    def closed?
+      @closed
+    end
+
+    private
+
+    def ensure_open!
+      raise EncoderError, "encoder is closed" if @closed
+    end
+
+    def validate_samples!(samples)
+      unless samples.is_a?(Array)
+        raise ArgumentError, "samples must be an array of per-channel sample arrays"
+      end
+
+      expected_channels = @info.channels
+      unless samples.size == expected_channels
+        raise ArgumentError, "expected #{expected_channels} channels, got #{samples.size}"
+      end
+
+      num_samples = nil
+
+      samples.each_with_index do |channel_data, channel_index|
+        unless channel_data.is_a?(Array)
+          raise ArgumentError, "channel #{channel_index} must be an array of numeric samples"
+        end
+
+        num_samples ||= channel_data.size
+        unless channel_data.size == num_samples
+          raise ArgumentError, "all channels must have the same number of samples"
+        end
+      end
+    end
+
+    def flush_blocks
+      while @block.blockout
+        @block.analysis_and_addblock
+
+        while (packet = @block.flush_packet)
+          @stream.packetin(packet)
+
+          while (page = @stream.pageout)
+            yield page.to_s
+            break if page.eos?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vorbis/info.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Vorbis
+  class Info
+    include Clearable
+
+    attr_reader :native
+
+    def initialize
+      @ptr = FFI::MemoryPointer.new(Native::VorbisInfo.size)
+      @native = Native::VorbisInfo.new(@ptr)
+      Native.vorbis_info_init(@ptr)
+      setup_clearable(Native.method(:vorbis_info_clear))
+    end
+
+    def encode_init_vbr(channels:, rate:, quality: 0.4)
+      result = NativeEnc.vorbis_encode_init_vbr(@ptr, channels, rate, quality)
+      raise InitError, "vorbis_encode_init_vbr failed with status #{result}" unless result == 0
+    end
+
+    def encode_init(channels:, rate:, max_bitrate: -1, nominal_bitrate:, min_bitrate: -1)
+      result = NativeEnc.vorbis_encode_init(@ptr, channels, rate, max_bitrate, nominal_bitrate, min_bitrate)
+      raise InitError, "vorbis_encode_init failed with status #{result}" unless result == 0
+    end
+
+    def channels
+      @native[:channels]
+    end
+
+    def rate
+      @native[:rate]
+    end
+
+    def bitrate_nominal
+      @native[:bitrate_nominal]
+    end
+  end
+end

data/lib/vorbis/native.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module Vorbis
+  module Native
+    extend FFI::Library
+    ffi_lib ["libvorbis.so.0", "libvorbis.0.dylib", "libvorbis", "vorbis"]
+
+    # --- Structs ---
+
+    class VorbisInfo < FFI::Struct
+      layout :version,          :int,
+             :channels,         :int,
+             :rate,             :long,
+             :bitrate_upper,    :long,
+             :bitrate_nominal,  :long,
+             :bitrate_lower,    :long,
+             :bitrate_window,   :long,
+             :codec_setup,      :pointer
+    end
+
+    class VorbisComment < FFI::Struct
+      layout :user_comments,    :pointer,
+             :comment_lengths,  :pointer,
+             :comments,         :int,
+             :vendor,           :pointer
+    end
+
+    class VorbisDspState < FFI::Struct
+      layout :analysisp,      :int,
+             :vi,             :pointer,
+             :pcm,            :pointer,
+             :pcmret,         :pointer,
+             :pcm_storage,    :int,
+             :pcm_current,    :int,
+             :pcm_returned,   :int,
+             :preextrapolate, :int,
+             :eofflag,        :int,
+             :lW,             :long,
+             :W,              :long,
+             :nW,             :long,
+             :centerW,        :long,
+             :granulepos,     :int64,
+             :sequence,       :int64,
+             :glue_bits,      :int64,
+             :time_bits,      :int64,
+             :floor_bits,     :int64,
+             :res_bits,       :int64,
+             :backend_state,  :pointer
+    end
+
+    class VorbisBlock < FFI::Struct
+      layout :pcm,              :pointer,
+             # oggpack_buffer opb (inlined)
+             :opb_endbyte,      :long,
+             :opb_endbit,       :int,
+             :opb_buffer,       :pointer,
+             :opb_ptr,          :pointer,
+             :opb_storage,      :long,
+             # remaining fields
+             :lW,               :long,
+             :W,                :long,
+             :nW,               :long,
+             :pcmend,           :int,
+             :mode,             :int,
+             :eofflag,          :int,
+             :granulepos,       :int64,
+             :sequence,         :int64,
+             :vd,               :pointer,
+             :localstore,       :pointer,
+             :localtop,         :long,
+             :localalloc,       :long,
+             :totaluse,         :long,
+             :reap,             :pointer,
+             :glue_bits,        :long,
+             :time_bits,        :long,
+             :floor_bits,       :long,
+             :res_bits,         :long,
+             :internal,         :pointer
+    end
+
+    # --- Info API ---
+
+    attach_function :vorbis_info_init,      [:pointer],              :void
+    attach_function :vorbis_info_clear,     [:pointer],              :void
+    attach_function :vorbis_info_blocksize, [:pointer, :int],        :int
+
+    # --- Comment API ---
+
+    attach_function :vorbis_comment_init,       [:pointer],                         :void
+    attach_function :vorbis_comment_clear,      [:pointer],                         :void
+    attach_function :vorbis_comment_add,        [:pointer, :string],                :void
+    attach_function :vorbis_comment_add_tag,    [:pointer, :string, :string],       :void
+    attach_function :vorbis_comment_query,      [:pointer, :string, :int],          :pointer
+    attach_function :vorbis_comment_query_count, [:pointer, :string],               :int
+
+    # --- Synthesis/Analysis API ---
+
+    attach_function :vorbis_analysis_init,      [:pointer, :pointer],                                    :int
+    attach_function :vorbis_analysis_headerout,  [:pointer, :pointer, :pointer, :pointer, :pointer],     :int
+    attach_function :vorbis_analysis_buffer,     [:pointer, :int],                                       :pointer
+    attach_function :vorbis_analysis_wrote,      [:pointer, :int],                                       :int
+    attach_function :vorbis_analysis_blockout,   [:pointer, :pointer],                                   :int
+    attach_function :vorbis_analysis,            [:pointer, :pointer],                                   :int
+    attach_function :vorbis_bitrate_addblock,    [:pointer],                                             :int
+    attach_function :vorbis_bitrate_flushpacket, [:pointer, :pointer],                                   :int
+
+    # --- Synthesis API ---
+
+    attach_function :vorbis_synthesis_headerin,   [:pointer, :pointer, :pointer],    :int
+    attach_function :vorbis_synthesis_init,       [:pointer, :pointer],              :int
+    attach_function :vorbis_synthesis_restart,    [:pointer],                        :int
+    attach_function :vorbis_synthesis,            [:pointer, :pointer],              :int
+    attach_function :vorbis_synthesis_trackonly,  [:pointer, :pointer],              :int
+    attach_function :vorbis_synthesis_blockin,    [:pointer, :pointer],              :int
+    attach_function :vorbis_synthesis_pcmout,     [:pointer, :pointer],              :int
+    attach_function :vorbis_synthesis_lapout,     [:pointer, :pointer],              :int
+    attach_function :vorbis_synthesis_read,       [:pointer, :int],                  :int
+
+    # --- Block API ---
+
+    attach_function :vorbis_block_init,  [:pointer, :pointer], :int
+    attach_function :vorbis_block_clear, [:pointer],           :int
+
+    # --- DSP Cleanup ---
+
+    attach_function :vorbis_dsp_clear, [:pointer], :void
+
+    # --- Helpers ---
+
+    def self.packet_from_native(pkt_ptr)
+      native_pkt = Ogg::Native::OggPacket.new(pkt_ptr)
+      data = native_pkt[:packet].read_bytes(native_pkt[:bytes])
+      Ogg::Packet.new(
+        data: data,
+        bos: native_pkt[:b_o_s] != 0,
+        eos: native_pkt[:e_o_s] != 0,
+        granulepos: native_pkt[:granulepos],
+        packetno: native_pkt[:packetno]
+      )
+    end
+  end
+end

data/lib/vorbis/native_enc.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Vorbis
+  module NativeEnc
+    extend FFI::Library
+    ffi_lib ["libvorbisenc.so.2", "libvorbisenc.2.dylib", "libvorbisenc", "vorbisenc"]
+
+    attach_function :vorbis_encode_init,           [:pointer, :long, :long, :long, :long, :long], :int
+    attach_function :vorbis_encode_init_vbr,       [:pointer, :long, :long, :float],              :int
+    attach_function :vorbis_encode_setup_init,     [:pointer],                                     :int
+    attach_function :vorbis_encode_setup_managed,  [:pointer, :long, :long, :long, :long, :long], :int
+    attach_function :vorbis_encode_setup_vbr,      [:pointer, :long, :long, :float],              :int
+    attach_function :vorbis_encode_ctl,            [:pointer, :int, :pointer],                     :int
+  end
+end

data/lib/vorbis/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Vorbis
+  VERSION = "0.1.0"
+end

data/lib/vorbis.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "ffi"
+require "ogg"
+require_relative "vorbis/version"
+require_relative "vorbis/native"
+require_relative "vorbis/native_enc"
+require_relative "vorbis/clearable"
+require_relative "vorbis/info"
+require_relative "vorbis/comment"
+require_relative "vorbis/dsp_state"
+require_relative "vorbis/block"
+require_relative "vorbis/encoder"
+
+module Vorbis
+  class Error < StandardError; end
+  class EncoderError < Error; end
+  class InitError < Error; end
+end

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification
+name: vorbis
+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:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+- !ruby/object:Gem::Dependency
+  name: ogg-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+description: A Ruby FFI binding library for libvorbis and libvorbisenc, providing
+  Vorbis audio codec encoding functionality.
+email:
+- t.yudai92@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/vorbis.rb
+- lib/vorbis/block.rb
+- lib/vorbis/clearable.rb
+- lib/vorbis/comment.rb
+- lib/vorbis/dsp_state.rb
+- lib/vorbis/encoder.rb
+- lib/vorbis/info.rb
+- lib/vorbis/native.rb
+- lib/vorbis/native_enc.rb
+- lib/vorbis/version.rb
+homepage: https://github.com/ydah/vorbis-ruby
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/ydah/vorbis-ruby
+  source_code_uri: https://github.com/ydah/vorbis-ruby
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.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: Ruby FFI bindings for libvorbis and libvorbisenc
+test_files: []