wahwah 0.1.0 → 1.2.0

data/lib/wahwah/mp3/mpeg_frame_header.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module WahWah
+  module Mp3
+    # mpeg frame header structure:
+    #
+    # Position   Length    Meaning
+    # 0          11        Frame sync to find the header (all bits are always set)
+    #
+    # 11         2         Audio version ID
+    #                      00 - MPEG Version 2.5 (unofficial extension of MPEG 2)
+    #                      01 - reserved
+    #                      10 - MPEG Version 2 (ISO/IEC 13818-3)
+    #                      11 - MPEG Version 1 (ISO/IEC 11172-3)
+    #
+    # 13         2         Layer index
+    #                      00 - reserved
+    #                      01 - Layer III
+    #                      10 - Layer II
+    #                      11 - Layer I
+    #
+    # 15         1         Protection bit
+    #
+    # 16         4         Bitrate index, see FRAME_BITRATE_INDEX constant
+    #
+    # 20         2         Sampling rate index, see SAMPLE_RATE_INDEX constant
+    #
+    # 22         1         Padding bit
+    #
+    # 23         1         Private bit
+    #
+    # 24         2         Channel mode
+    #                      00 - Stereo
+    #                      01 - Joint Stereo (Stereo)
+    #                      10 - Dual channel (Two mono channels)
+    #                      11 - Single channel (Mono)
+    #
+    # 26         2         Mode extension (Only used in Joint Stereo)
+    #
+    # 28         1         Copyright bit (only informative)
+    #
+    # 29         1         Original bit (only informative)
+    #
+    # 30         2         Emphasis
+    class MpegFrameHeader
+      HEADER_SIZE = 4
+
+      FRAME_BITRATE_INDEX = {
+        "MPEG1 layer1" => [0, 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448, 0],
+        "MPEG1 layer2" => [0, 32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384, 0],
+        "MPEG1 layer3" => [0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 0],
+
+        "MPEG2 layer1" => [0, 32, 48, 56, 64, 80, 96, 112, 128, 144, 160, 176, 192, 224, 256, 0],
+        "MPEG2 layer2" => [0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, 0],
+        "MPEG2 layer3" => [0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, 0],
+
+        "MPEG2.5 layer1" => [0, 32, 48, 56, 64, 80, 96, 112, 128, 144, 160, 176, 192, 224, 256, 0],
+        "MPEG2.5 layer2" => [0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, 0],
+        "MPEG2.5 layer3" => [0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, 0]
+      }
+
+      VERSIONS_INDEX = ["MPEG2.5", nil, "MPEG2", "MPEG1"]
+      LAYER_INDEX = [nil, "layer3", "layer2", "layer1"]
+      CHANNEL_MODE_INDEX = ["Stereo", "Joint Stereo", "Dual Channel", "Single Channel"]
+
+      SAMPLE_RATE_INDEX = {
+        "MPEG1" => [44100, 48000, 32000],
+        "MPEG2" => [22050, 24000, 16000],
+        "MPEG2.5" => [11025, 12000, 8000]
+      }
+
+      SAMPLES_PER_FRAME_INDEX = {
+        "MPEG1 layer1" => 384,
+        "MPEG1 layer2" => 1152,
+        "MPEG1 layer3" => 1152,
+
+        "MPEG2 layer1" => 384,
+        "MPEG2 layer2" => 1152,
+        "MPEG2 layer3" => 576,
+
+        "MPEG2.5 layer1" => 384,
+        "MPEG2.5 layer2" => 1152,
+        "MPEG2.5 layer3" => 576
+      }
+
+      attr_reader :version, :layer, :frame_bitrate, :channel_mode, :sample_rate
+
+      def initialize(file_io, offset = 0)
+        # mpeg frame header start with '11111111111' sync bits,
+        # So look through file until find it.
+        loop do
+          file_io.rewind
+          file_io.seek(offset)
+
+          break if file_io.eof?
+
+          header = file_io.read(HEADER_SIZE)
+          sync_bits = header.unpack1("B11")
+
+          if sync_bits == ("1" * 11).b
+            @header = header.unpack1("B*")
+            @position = offset
+
+            parse
+            break
+          end
+
+          offset += 1
+        end
+      end
+
+      def valid?
+        !@header.nil?
+      end
+
+      def position
+        return 0 unless valid?
+        @position
+      end
+
+      def kind
+        return if @version.nil? && @layer.nil?
+        "#{@version} #{@layer}"
+      end
+
+      def samples_per_frame
+        SAMPLES_PER_FRAME_INDEX[kind]
+      end
+
+      private
+
+      def parse
+        return unless valid?
+
+        @version = VERSIONS_INDEX[@header[11..12].to_i(2)]
+        @layer = LAYER_INDEX[@header[13..14].to_i(2)]
+        @frame_bitrate = FRAME_BITRATE_INDEX[kind]&.fetch(@header[16..19].to_i(2))
+        @channel_mode = CHANNEL_MODE_INDEX[@header[24..25].to_i(2)]
+        @sample_rate = SAMPLE_RATE_INDEX[@version]&.fetch(@header[20..21].to_i(2))
+      end
+    end
+  end
+end

data/lib/wahwah/mp3/vbri_header.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module WahWah
+  module Mp3
+    # VBRI header structure:
+    #
+    # Position    Length    Meaning
+    # 0           4         VBR header ID in 4 ASCII chars, always 'VBRI', not NULL-terminated
+    #
+    # 4           2         Version ID as Big-Endian 16-bit unsigned
+    #
+    # 6           2         Delay as Big-Endian float
+    #
+    # 8           2         Quality indicator
+    #
+    # 10          4         Number of Bytes as Big-Endian 32-bit unsigned
+    #
+    # 14          4         Number of Frames as Big-Endian 32-bit unsigned
+    #
+    # 18          2         Number of entries within TOC table as Big-Endian 16-bit unsigned
+    #
+    # 20          2         Scale factor of TOC table entries as Big-Endian 32-bit unsigned
+    #
+    # 22          2         Size per table entry in bytes (max 4) as Big-Endian 16-bit unsigned
+    #
+    # 24          2         Frames per table entry as Big-Endian 16-bit unsigned
+    #
+    # 26                    TOC entries for seeking as Big-Endian integral.
+    #                       From size per table entry and number of entries,
+    #                       you can calculate the length of this field.
+    class VbriHeader
+      HEADER_SIZE = 32
+      HEADER_FORMAT = "A4x6NN"
+
+      attr_reader :frames_count, :bytes_count
+
+      def initialize(file_io, offset = 0)
+        file_io.seek(offset)
+        @id, @bytes_count, @frames_count = file_io.read(HEADER_SIZE)&.unpack(HEADER_FORMAT)
+      end
+
+      def valid?
+        @id == "VBRI"
+      end
+    end
+  end
+end

data/lib/wahwah/mp3/xing_header.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module WahWah
+  module Mp3
+    # Xing header structure:
+    #
+    # Position                Length    Meaning
+    # 0                       4         VBR header ID in 4 ASCII chars, either 'Xing' or 'Info',
+    #                                   not NULL-terminated
+    #
+    # 4                       4         Flags which indicate what fields are present,
+    #                                   flags are combined with a logical OR. Field is mandatory.
+    #
+    #                                   0x0001 - Frames field is present
+    #                                   0x0002 - Bytes field is present
+    #                                   0x0004 - TOC field is present
+    #                                   0x0008 - Quality indicator field is present
+    #
+    # 8                       4         Number of Frames as Big-Endian 32-bit unsigned (optional)
+    #
+    # 8 or 12                 4         Number of Bytes in file as Big-Endian 32-bit unsigned (optional)
+    #
+    # 8,12 or 16              100       100 TOC entries for seeking as integral BYTE (optional)
+    #
+    # 8,12,16,108,112 or 116  4         Quality indicator as Big-Endian 32-bit unsigned
+    #                                   from 0 - best quality to 100 - worst quality (optional)
+    class XingHeader
+      attr_reader :frames_count, :bytes_count
+
+      def initialize(file_io, offset = 0)
+        file_io.seek(offset)
+
+        @id, @flags = file_io.read(8)&.unpack("A4N")
+        return unless valid?
+
+        @frames_count = @flags & 1 == 1 ? file_io.read(4).unpack1("N") : 0
+        @bytes_count = @flags & 2 == 2 ? file_io.read(4).unpack1("N") : 0
+      end
+
+      def valid?
+        %w[Xing Info].include? @id
+      end
+    end
+  end
+end

data/lib/wahwah/mp3_tag.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module WahWah
+  class Mp3Tag < Tag
+    extend TagDelegate
+    extend Forwardable
+
+    def_delegator :@mpeg_frame_header, :version, :mpeg_version
+    def_delegator :@mpeg_frame_header, :layer, :mpeg_layer
+    def_delegator :@mpeg_frame_header, :kind, :mpeg_kind
+    def_delegators :@mpeg_frame_header, :channel_mode, :sample_rate
+
+    tag_delegate :@id3_tag,
+      :title,
+      :artist,
+      :album,
+      :albumartist,
+      :composer,
+      :comments,
+      :track,
+      :track_total,
+      :genre,
+      :year,
+      :disc,
+      :disc_total,
+      :images
+
+    def id3v2?
+      @id3_tag.instance_of? ID3::V2
+    end
+
+    def invalid_id3?
+      @id3_tag.nil?
+    end
+
+    def id3_version
+      @id3_tag&.version
+    end
+
+    def is_vbr?
+      mpeg_frame_header.valid? && (xing_header.valid? || vbri_header.valid?)
+    end
+
+    private
+
+    def parse
+      @id3_tag = parse_id3_tag
+      parse_duration if mpeg_frame_header.valid?
+    end
+
+    def parse_id3_tag
+      id3_v1_tag = ID3::V1.new(@file_io.dup)
+      id3_v2_tag = ID3::V2.new(@file_io.dup)
+
+      return id3_v2_tag if id3_v2_tag.valid?
+      id3_v1_tag if id3_v1_tag.valid?
+    end
+
+    def parse_duration
+      if is_vbr?
+        @duration = frames_count * (mpeg_frame_header.samples_per_frame / sample_rate.to_f)
+        @bitrate = (bytes_count * 8 / @duration / 1000).round unless @duration.zero?
+      else
+        @bitrate = mpeg_frame_header.frame_bitrate
+        @duration = (file_size - (@id3_tag&.size || 0)) * 8 / (@bitrate * 1000).to_f unless @bitrate.zero?
+      end
+    end
+
+    def mpeg_frame_header
+      # Because id3v2 tag on the file header so skip id3v2 tag
+      @mpeg_frame_header ||= Mp3::MpegFrameHeader.new(@file_io, id3v2? ? @id3_tag&.size : 0)
+    end
+
+    def xing_header
+      @xing_header ||= Mp3::XingHeader.new(@file_io, xing_header_offset)
+    end
+
+    def vbri_header
+      @vbri_header ||= Mp3::VbriHeader.new(@file_io, vbri_header_offset)
+    end
+
+    def xing_header_offset
+      mpeg_frame_header_position = mpeg_frame_header.position
+      mpeg_frame_header_size = Mp3::MpegFrameHeader::HEADER_SIZE
+      mpeg_frame_side_info_size = if mpeg_version == "MPEG1"
+        channel_mode == "Single Channel" ? 17 : 32
+      else
+        channel_mode == "Single Channel" ? 9 : 17
+      end
+
+      mpeg_frame_header_position + mpeg_frame_header_size + mpeg_frame_side_info_size
+    end
+
+    def vbri_header_offset
+      mpeg_frame_header_position = mpeg_frame_header.position
+      mpeg_frame_header_size = Mp3::MpegFrameHeader::HEADER_SIZE
+
+      mpeg_frame_header_position + mpeg_frame_header_size + 32
+    end
+
+    def frames_count
+      return xing_header.frames_count if xing_header.valid?
+      vbri_header.frames_count if vbri_header.valid?
+    end
+
+    def bytes_count
+      return xing_header.bytes_count if xing_header.valid?
+      vbri_header.bytes_count if vbri_header.valid?
+    end
+  end
+end

data/lib/wahwah/mp4/atom.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module WahWah
+  module Mp4
+    class Atom
+      prepend LazyRead
+
+      VERSIONED_ATOMS = %w[meta stsd]
+      FLAGGED_ATOMS = %w[stsd]
+      HEADER_SIZE = 8
+      HEADER_SIZE_FIELD_SIZE = 4
+      EXTENDED_HEADER_SIZE = 8
+
+      attr_reader :type
+
+      def self.find(file_io, *atom_path)
+        file_io.rewind
+
+        atom_type = atom_path.shift
+
+        until file_io.eof?
+          atom = new(file_io)
+
+          next unless atom.valid?
+          file_io.seek(atom.size, IO::SEEK_CUR)
+          next unless atom.type == atom_type
+
+          return atom if atom_path.empty?
+          return atom.find(*atom_path)
+        end
+
+        # Return empty atom if can not found
+        new(StringIO.new(""))
+      end
+
+      # An atom header consists of the following fields:
+      #
+      # Atom size:
+      # A 32-bit integer that indicates the size of the atom, including both the atom header and the atom’s contents,
+      # including any contained atoms. Normally, the size field contains the actual size of the atom.
+      #
+      # Type:
+      # A 32-bit integer that contains the type of the atom.
+      # This can often be usefully treated as a four-character field with a mnemonic value .
+      def initialize
+        @size, @type = @file_io.read(HEADER_SIZE)&.unpack("Na4")
+        return unless valid?
+
+        # If the size field of an atom is set to 1, the type field is followed by a 64-bit extended size field,
+        # which contains the actual size of the atom as a 64-bit unsigned integer.
+        @size = @file_io.read(EXTENDED_HEADER_SIZE).unpack1("Q>") - EXTENDED_HEADER_SIZE if @size == 1
+
+        # If the size field of an atom is set to 0, which is allowed only for a top-level atom,
+        # designates the last atom in the file and indicates that the atom extends to the end of the file.
+        @size = @file_io.size if @size == 0
+        @size -= HEADER_SIZE
+      end
+
+      def valid?
+        !@size.nil? && @size >= HEADER_SIZE
+      end
+
+      def find(*atom_path)
+        child_atom_index = data.index(atom_path.first)
+
+        # Return empty atom if can not found
+        return self.class.new(StringIO.new("")) if child_atom_index.nil?
+
+        # Because before atom type field there are 4 bytes of size field,
+        # So the child_atom_index should reduce 4.
+        self.class.find(StringIO.new(data[child_atom_index - HEADER_SIZE_FIELD_SIZE..]), *atom_path)
+      end
+
+      def children
+        @children ||= parse_children_atoms
+      end
+
+      private
+
+      def parse_children_atoms
+        children_atoms = []
+        atoms_data = data
+
+        # Some atoms data contain extra content before child atom data.
+        # So reduce those extra content to get child atom data.
+        atoms_data = atoms_data[4..] if VERSIONED_ATOMS.include? type # Skip 4 bytes for version
+        atoms_data = atoms_data[4..] if FLAGGED_ATOMS.include? type # Skip 4 bytes for flag
+        atoms_data_io = StringIO.new(atoms_data)
+
+        until atoms_data_io.eof?
+          atom = self.class.new(atoms_data_io)
+          children_atoms.push(atom)
+
+          atom.skip
+        end
+
+        children_atoms
+      end
+    end
+  end
+end

data/lib/wahwah/mp4_tag.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+module WahWah
+  class Mp4Tag < Tag
+    META_ATOM_MAPPING = {
+      "\xA9alb".b => :album,
+      "\xA9ART".b => :artist,
+      "\xA9cmt".b => :comment,
+      "\xA9wrt".b => :composer,
+      "\xA9day".b => :year,
+      "\xA9gen".b => :genre,
+      "\xA9nam".b => :title,
+      "covr".b => :image,
+      "disk".b => :disc,
+      "trkn".b => :track,
+      "aART".b => :albumartist
+    }
+
+    META_ATOM_DECODE_BY_TYPE = {
+      0 => ->(data) { data }, # reserved
+      1 => ->(data) { Helper.encode_to_utf8(data) }, # UTF-8
+      2 => ->(data) { Helper.encode_to_utf8(data, "UTF-16BE") }, # UTF-16BE
+      3 => ->(data) { Helper.encode_to_utf8(data, "SJIS") }, # SJIS
+
+      13 => ->(data) { {data: data, mime_type: "image/jpeg", type: :cover} }, # JPEG
+      14 => ->(data) { {data: data, mime_type: "image/png", type: :cover} }, # PNG
+
+      21 => ->(data) { data.unpack1("i>") }, # Big endian signed integer
+      22 => ->(data) { data.unpack1("I>") }, # Big endian unsigned integer
+      23 => ->(data) { data.unpack1("g") }, # Big endian 32-bit floating point value
+      24 => ->(data) { data.unpack1("G") }, # Big endian 64-bit floating point value
+
+      65 => ->(data) { data.unpack1("c") }, # 8-bit signed integer
+      66 => ->(data) { data.unpack1("s>") }, # Big-endian 16-bit signed integer
+      67 => ->(data) { data.unpack1("l>") }, # Big-endian 32-bit signed integer
+      74 => ->(data) { data.unpack1("q>") }, # Big-endian 64-bit signed integer
+
+      75 => ->(data) { data.unpack1("C") }, # 8-bit unsigned integer
+      76 => ->(data) { data.unpack1("S>") }, # Big-endian 16-bit unsigned integer
+      77 => ->(data) { data.unpack1("L>") }, # Big-endian 32-bit unsigned integer
+      78 => ->(data) { data.unpack1("Q>") } # Big-endian 64-bit unsigned integer
+    }
+
+    private
+
+    def parse
+      movie_atom = Mp4::Atom.find(@file_io, "moov")
+      return unless movie_atom.valid?
+
+      parse_meta_list_atom movie_atom.find("udta", "meta", "ilst")
+      parse_mvhd_atom movie_atom.find("mvhd")
+      parse_stsd_atom movie_atom.find("trak", "mdia", "minf", "stbl", "stsd")
+    end
+
+    def parse_meta_list_atom(atom)
+      return unless atom.valid?
+
+      # The metadata item list atom holds a list of actual metadata values that are present in the metadata atom.
+      # The metadata items are formatted as a list of items.
+      # The metadata item list atom is of type ‘ilst’ and contains a number of metadata items, each of which is an atom.
+      # each metadata item atom contains a Value Atom, to hold the value of the metadata item
+      atom.children.each do |child_atom|
+        attr_name = META_ATOM_MAPPING[child_atom.type]
+
+        # The value of the metadata item is expressed as immediate data in a value atom.
+        # The value atom starts with two fields: a type indicator, and a locale indicator.
+        # Both the type and locale indicators are four bytes long.
+        # There may be multiple ‘value’ entries, using different type
+        data_atom = child_atom.find("data")
+        next unless data_atom.valid?
+
+        if attr_name == :image
+          @images_data.push(data_atom)
+          next
+        end
+
+        encoded_data_value = parse_meta_data_atom(data_atom)
+        next if attr_name.nil? || encoded_data_value.nil?
+
+        case attr_name
+        when :comment
+          @comments.push(encoded_data_value)
+        when :track, :disc
+          count, total_count = encoded_data_value.unpack("x2nn")
+
+          instance_variable_set("@#{attr_name}", count) unless count.zero?
+          instance_variable_set("@#{attr_name}_total", total_count) unless total_count.zero?
+        else
+          instance_variable_set("@#{attr_name}", encoded_data_value)
+        end
+      end
+    end
+
+    def parse_meta_data_atom(atom)
+      data_type, data_value = atom.data.unpack("Nx4a*")
+      META_ATOM_DECODE_BY_TYPE[data_type]&.call(data_value)
+    end
+
+    def parse_mvhd_atom(atom)
+      return unless atom.valid?
+
+      atom_data = StringIO.new(atom.data)
+      version = atom_data.read(1).unpack1("c")
+
+      # Skip flags
+      atom_data.seek(3, IO::SEEK_CUR)
+
+      if version == 0
+        # Skip creation and modification time
+        atom_data.seek(8, IO::SEEK_CUR)
+
+        time_scale, duration = atom_data.read(8).unpack("l>l>")
+      elsif version == 1
+        # Skip creation and modification time
+        atom_data.seek(16, IO::SEEK_CUR)
+
+        time_scale, duration = atom_data.read(12).unpack("l>q>")
+      end
+
+      @duration = duration / time_scale.to_f
+    end
+
+    def parse_stsd_atom(atom)
+      return unless atom.valid?
+
+      mp4a_atom = atom.find("mp4a")
+      esds_atom = atom.find("esds")
+
+      @sample_rate = mp4a_atom.data.unpack1("x22I>") if mp4a_atom.valid?
+      @bitrate = esds_atom.data.unpack1("x26I>") / 1000 if esds_atom.valid?
+    end
+
+    def parse_image_data(image_data_atom)
+      parse_meta_data_atom(image_data_atom)
+    end
+  end
+end

data/lib/wahwah/ogg/flac_tag.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module WahWah
+  module Ogg
+    class FlacTag
+      include VorbisComment
+      include Flac::StreaminfoBlock
+
+      attr_reader :bitrate, :duration, :sample_rate, :bit_depth, *COMMET_FIELD_MAPPING.values
+
+      def initialize(identification_packet, comment_packet)
+        # Identification packet structure:
+        #
+        # The one-byte packet type 0x7F
+        # The four-byte ASCII signature "FLAC", i.e. 0x46, 0x4C, 0x41, 0x43
+        # A one-byte binary major version number for the mapping, e.g. 0x01 for mapping version 1.0
+        # A one-byte binary minor version number for the mapping, e.g. 0x00 for mapping version 1.0
+        # A two-byte, big-endian binary number signifying the number of header (non-audio) packets, not including this one.
+        # The four-byte ASCII native FLAC signature "fLaC" according to the FLAC format specification
+        # The STREAMINFO metadata block for the stream.
+        #
+        # The first identification packet is followed by one or more header packets.
+        # Each such packet will contain a single native FLAC metadata block.
+        # The first of these must be a VORBIS_COMMENT block.
+
+        id, streaminfo_block_data = identification_packet.unpack("x9A4A*")
+
+        return unless id == "fLaC"
+        streaminfo_block = Flac::Block.new(StringIO.new(streaminfo_block_data))
+        vorbis_comment_block = Flac::Block.new(StringIO.new(comment_packet))
+
+        parse_streaminfo_block(streaminfo_block.data)
+        parse_vorbis_comment(vorbis_comment_block.data)
+      end
+    end
+  end
+end

data/lib/wahwah/ogg/opus_tag.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module WahWah
+  module Ogg
+    class OpusTag
+      include VorbisComment
+
+      attr_reader :sample_rate, :pre_skip, *COMMET_FIELD_MAPPING.values
+
+      def initialize(identification_packet, comment_packet)
+        # Identification packet structure:
+        #
+        # 1) "OpusHead"
+        # 2) [version] = read 8 bits as unsigned integer
+        # 3) [audio_channels] = read 8 bit as unsigned integer
+        # 4) [pre_skip] = read 16 bits as unsigned little endian integer
+        # 5) [input_sample_rate] = read 32 bits as unsigned little endian integer
+        # 6) [output_gain] = read 16 bits as unsigned little endian integer
+        # 7) [channel_mapping_family] = read 8 bit as unsigned integer
+        # 8) [channel_mapping_table]
+        @sample_rate = 48000
+        @pre_skip = identification_packet[10..11].unpack1("v")
+
+        comment_packet_id, comment_packet_body = [comment_packet[0..7], comment_packet[8..]]
+
+        # Opus comment packet start with 'OpusTags'
+        return unless comment_packet_id == "OpusTags"
+
+        parse_vorbis_comment(comment_packet_body)
+      end
+    end
+  end
+end

data/lib/wahwah/ogg/packets.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module WahWah
+  module Ogg
+    # From Ogg's perspective, packets can be of any arbitrary size.  A
+    # specific media mapping will define how to group or break up packets
+    # from a specific media encoder.  As Ogg pages have a maximum size of
+    # about 64 kBytes, sometimes a packet has to be distributed over
+    # several pages. To simplify that process, Ogg divides each packet
+    # into 255 byte long chunks plus a final shorter chunk. These chunks
+    # are called "Ogg Segments". They are only a logical construct and do
+    # not have a header for themselves.
+    class Packets
+      include Enumerable
+
+      def initialize(file_io)
+        @file_io = file_io
+      end
+
+      def each
+        @file_io.rewind
+
+        packet = +""
+        pages = Ogg::Pages.new(@file_io)
+
+        pages.each do |page|
+          page.segments.each do |segment|
+            packet << segment
+
+            # Ogg divides each packet into 255 byte long segments plus a final shorter segment.
+            # So when segment length is less than 255 byte, it's the final segment.
+            if segment.length < 255
+              yield packet
+              packet = +""
+            end
+          end
+        end
+      end
+    end
+  end
+end