wahwah 0.1.0 → 1.0.0

data/lib/wahwah/mp3_tag.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+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?
+      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)
+        id3_v2_tag = ID3::V2.new(@file_io)
+
+        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)).round
+          @bitrate = bytes_count * 8 / @duration / 1000 unless @duration.zero?
+        else
+          @bitrate = mpeg_frame_header.frame_bitrate
+          @duration = (file_size - (@id3_tag&.size || 0)) * 8 / (@bitrate * 1000) 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 = mpeg_version == 'MPEG1' ?
+          (channel_mode == 'Single Channel' ? 17 : 32) :
+          (channel_mode == 'Single Channel' ? 9 : 17)
+
+        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,105 @@
+# frozen_string_literal: true
+
+module WahWah
+  module Mp4
+    class Atom
+      VERSIONED_ATOMS = %w(meta stsd)
+      FLAGGED_ATOMS = %w(stsd)
+      HEADER_SIZE = 8
+      HEADER_SIZE_FIELD_SIZE = 4
+      EXTENDED_HEADER_SIZE = 8
+
+      attr_reader :size, :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(file_io)
+        @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).unpack('Q>').first - 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 = @size - HEADER_SIZE
+        @file_io = file_io
+        @position = file_io.pos
+      end
+
+      def data
+        @file_io.seek(@position)
+        @file_io.read(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..-1]), *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..-1] if VERSIONED_ATOMS.include? type # Skip 4 bytes for version
+          atoms_data = atoms_data[4..-1] 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)
+
+            atoms_data_io.seek(atom.size, IO::SEEK_CUR)
+          end
+
+          children_atoms
+        end
+    end
+  end
+end

data/lib/wahwah/mp4_tag.rb

@@ -0,0 +1,126 @@
+# 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.unpack('i>').first }, # Big endian signed integer
+      22 => -> (data) { data.unpack('I>').first }, # Big endian unsigned integer
+      23 => -> (data) { data.unpack('g').first }, # Big endian 32-bit floating point value
+      24 => -> (data) { data.unpack('G').first }, # Big endian 64-bit floating point value
+
+      65 => -> (data) { data.unpack('c').first }, # 8-bit signed integer
+      66 => -> (data) { data.unpack('s>').first }, # Big-endian 16-bit signed integer
+      67 => -> (data) { data.unpack('l>').first }, # Big-endian 32-bit signed integer
+      74 => -> (data) { data.unpack('q>').first }, # Big-endian 64-bit signed integer
+
+      75 => -> (data) { data.unpack('C').first }, # 8-bit unsigned integer
+      76 => -> (data) { data.unpack('S>').first }, # Big-endian 16-bit unsigned integer
+      77 => -> (data) { data.unpack('L>').first }, # Big-endian 32-bit unsigned integer
+      78 => -> (data) { data.unpack('Q>').first } # 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|
+          attribute_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')
+          return unless data_atom.valid?
+
+          data_type, data_value = data_atom.data.unpack('Nx4a*')
+          encoded_data_value = META_ATOM_DECODE_BY_TYPE[data_type]&.call(data_value)
+
+          next if attribute_name.nil? || encoded_data_value.nil?
+
+          case attribute_name
+          when :image
+            @images.push(encoded_data_value)
+          when :comment
+            @comments.push(encoded_data_value)
+          when :track, :disc
+            count, total_count = encoded_data_value.unpack('x2nn')
+
+            instance_variable_set("@#{attribute_name}", count) unless count.zero?
+            instance_variable_set("@#{attribute_name}_total", total_count) unless total_count.zero?
+          else
+            instance_variable_set("@#{attribute_name}", encoded_data_value)
+          end
+        end
+      end
+
+      def parse_mvhd_atom(atom)
+        return unless atom.valid?
+
+        atom_data = StringIO.new(atom.data)
+        version = atom_data.read(1).unpack('c').first
+
+        # 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).round
+      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.unpack('x22I>').first if mp4a_atom.valid?
+        @bitrate = esds_atom.data.unpack('x26I>').first / 1000 if esds_atom.valid?
+      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, *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].unpack('v').first
+
+        comment_packet_id, comment_packet_body = [comment_packet[0..7], comment_packet[8..-1]]
+
+        # 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