wahwah 1.0.0 → 1.3.0

data/lib/wahwah/mp4_tag.rb

@@ -10,117 +10,128 @@ module WahWah
       "\xA9day".b => :year,
       "\xA9gen".b => :genre,
       "\xA9nam".b => :title,
-      'covr'.b => :image,
-      'disk'.b => :disc,
-      'trkn'.b => :track,
-      'aART'.b => :albumartist
+      "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
+      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
+      movie_atom = Mp4::Atom.find(@file_io, "moov")
+      return unless movie_atom.valid?
+
+      parse_meta_list_atom movie_atom.find("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")
 
-      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
+          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_mvhd_atom(atom)
-        return unless atom.valid?
+    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
 
-        atom_data = StringIO.new(atom.data)
-        version = atom_data.read(1).unpack('c').first
+    def parse_mvhd_atom(atom)
+      return unless atom.valid?
 
-        # Skip flags
-        atom_data.seek(3, IO::SEEK_CUR)
+      atom_data = StringIO.new(atom.data)
+      version = atom_data.read(1).unpack1("c")
 
-        if version == 0
-          # Skip creation and modification time
-          atom_data.seek(8, IO::SEEK_CUR)
+      # Skip flags
+      atom_data.seek(3, 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)
+      if version == 0
+        # Skip creation and modification time
+        atom_data.seek(8, IO::SEEK_CUR)
 
-          time_scale, duration = atom_data.read(12).unpack('l>q>')
-        end
+        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)
 
-        @duration = (duration / time_scale.to_f).round
+        time_scale, duration = atom_data.read(12).unpack("l>q>")
       end
 
-      def parse_stsd_atom(atom)
-        return unless atom.valid?
+      @duration = duration / time_scale.to_f
+    end
 
-        mp4a_atom = atom.find('mp4a')
-        esds_atom = atom.find('esds')
+    def parse_stsd_atom(atom)
+      return unless atom.valid?
 
-        @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
+      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

@@ -6,7 +6,7 @@ module WahWah
       include VorbisComment
       include Flac::StreaminfoBlock
 
-      attr_reader :bitrate, :duration, :sample_rate, *COMMET_FIELD_MAPPING.values
+      attr_reader :bitrate, :duration, :sample_rate, :bit_depth, *COMMET_FIELD_MAPPING.values
 
       def initialize(identification_packet, comment_packet)
         # Identification packet structure:
@@ -23,9 +23,9 @@ module WahWah
         # 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*')
+        id, streaminfo_block_data = identification_packet.unpack("x9A4A*")
 
-        return unless id == 'fLaC'
+        return unless id == "fLaC"
         streaminfo_block = Flac::Block.new(StringIO.new(streaminfo_block_data))
         vorbis_comment_block = Flac::Block.new(StringIO.new(comment_packet))
 

data/lib/wahwah/ogg/opus_tag.rb

@@ -19,12 +19,12 @@ module WahWah
         # 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
+        @pre_skip = identification_packet[10..11].unpack1("v")
 
-        comment_packet_id, comment_packet_body = [comment_packet[0..7], comment_packet[8..-1]]
+        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'
+        return unless comment_packet_id == "OpusTags"
 
         parse_vorbis_comment(comment_packet_body)
       end

data/lib/wahwah/ogg/packets.rb

@@ -20,7 +20,7 @@ module WahWah
       def each
         @file_io.rewind
 
-        packet = +''
+        packet = +""
         pages = Ogg::Pages.new(@file_io)
 
         pages.each do |page|
@@ -31,7 +31,7 @@ module WahWah
             # So when segment length is less than 255 byte, it's the final segment.
             if segment.length < 255
               yield packet
-              packet = +''
+              packet = +""
             end
           end
         end

data/lib/wahwah/ogg/page.rb

@@ -99,7 +99,7 @@ module WahWah
     #    lacing value.
     class Page
       HEADER_SIZE = 27
-      HEADER_FORMAT = 'A4CxQx12C'
+      HEADER_FORMAT = "A4CxQx12C"
 
       attr_reader :segments, :granule_position
 
@@ -109,12 +109,12 @@ module WahWah
 
         return unless valid?
 
-        segment_table = file_io.read(page_segments).unpack('C' * page_segments)
+        segment_table = file_io.read(page_segments).unpack("C" * page_segments)
         @segments = segment_table.map { |segment_length| file_io.read(segment_length) }
       end
 
       def valid?
-        @capture_pattern == 'OggS' && @version == 0
+        @capture_pattern == "OggS" && @version == 0
       end
     end
   end

data/lib/wahwah/ogg/vorbis_comment.rb

@@ -16,32 +16,32 @@ module WahWah
     # 9) done.
     module VorbisComment
       COMMET_FIELD_MAPPING = {
-        'TITLE' => :title,
-        'ALBUM' => :album,
-        'ALBUMARTIST' => :albumartist,
-        'TRACKNUMBER' => :track,
-        'ARTIST' => :artist,
-        'DATE' => :year,
-        'GENRE' => :genre,
-        'DISCNUMBER' => :disc,
-        'COMPOSER' => :composer
+        "TITLE" => :title,
+        "ALBUM" => :album,
+        "ALBUMARTIST" => :albumartist,
+        "TRACKNUMBER" => :track,
+        "ARTIST" => :artist,
+        "DATE" => :year,
+        "GENRE" => :genre,
+        "DISCNUMBER" => :disc,
+        "COMPOSER" => :composer
       }
 
       def parse_vorbis_comment(comment_content)
         comment_content = StringIO.new(comment_content)
 
-        vendor_length = comment_content.read(4).unpack('V').first
+        vendor_length = comment_content.read(4).unpack1("V")
         comment_content.seek(vendor_length, IO::SEEK_CUR) # Skip vendor_string
 
-        comment_list_length = comment_content.read(4).unpack('V').first
+        comment_list_length = comment_content.read(4).unpack1("V")
 
         comment_list_length.times do
-          comment_length = comment_content.read(4).unpack('V').first
+          comment_length = comment_content.read(4).unpack1("V")
           comment = Helper.encode_to_utf8(comment_content.read(comment_length))
-          field_name, field_value = comment.split('=', 2)
-          attr_name = COMMET_FIELD_MAPPING[field_name]
+          field_name, field_value = comment.split("=", 2)
+          attr_name = COMMET_FIELD_MAPPING[field_name&.upcase]
 
-          field_value = field_value.to_i if %i(track disc).include? attr_name
+          field_value = field_value.to_i if %i[track disc].include? attr_name
 
           instance_variable_set("@#{attr_name}", field_value) unless attr_name.nil?
         end

data/lib/wahwah/ogg/vorbis_tag.rb

@@ -20,10 +20,10 @@ module WahWah
         # 8) [blocksize_0] = 2 exponent (read 4 bits as unsigned integer)
         # 9) [blocksize_1] = 2 exponent (read 4 bits as unsigned integer)
         # 10) [framing_flag] = read one bit
-        @sample_rate, bitrate = identification_packet[12, 12].unpack('Vx4V')
+        @sample_rate, bitrate = identification_packet[12, 12].unpack("Vx4V")
         @bitrate = bitrate / 1000
 
-        comment_packet_id, comment_packet_body = [comment_packet[0..6], comment_packet[7..-1]]
+        comment_packet_id, comment_packet_body = [comment_packet[0..6], comment_packet[7..]]
 
         # Vorbis comment packet start with "\x03vorbis"
         return unless comment_packet_id == "\x03vorbis"

data/lib/wahwah/ogg_tag.rb

@@ -16,51 +16,51 @@ module WahWah
       :composer,
       :sample_rate
 
-    def duration
-      @duration ||= parse_duration
+    private
+
+    def packets
+      @packets ||= Ogg::Packets.new(@file_io)
     end
 
-    def bitrate
-      @bitrate ||= parse_bitrate
+    def pages
+      @pages ||= Ogg::Pages.new(@file_io)
     end
 
-    private
-      def packets
-        @packets ||= Ogg::Packets.new(@file_io)
-      end
+    def parse
+      identification_packet, comment_packet = packets.first(2)
+      return if identification_packet.nil? || comment_packet.nil?
 
-      def pages
-        @pages ||= Ogg::Pages.new(@file_io)
+      @overhead_packets_size = identification_packet.size + comment_packet.size
+
+      @tag = if identification_packet.start_with?("\x01vorbis")
+        Ogg::VorbisTag.new(identification_packet, comment_packet)
+      elsif identification_packet.start_with?("OpusHead")
+        Ogg::OpusTag.new(identification_packet, comment_packet)
+      elsif identification_packet.start_with?("\x7FFLAC")
+        Ogg::FlacTag.new(identification_packet, comment_packet)
       end
 
-      def parse
-        identification_packet, comment_packet = packets.first(2)
-        return if identification_packet.nil? || comment_packet.nil?
+      @duration = parse_duration
+      @bitrate = parse_bitrate
+      @bit_depth = parse_bit_depth
+    end
 
-        @overhead_packets_size = identification_packet.size + comment_packet.size
+    def parse_duration
+      return @tag.duration if @tag.respond_to? :duration
 
-        @tag = case true
-               when identification_packet.start_with?("\x01vorbis")
-                 Ogg::VorbisTag.new(identification_packet, comment_packet)
-               when identification_packet.start_with?('OpusHead')
-                 Ogg::OpusTag.new(identification_packet, comment_packet)
-               when identification_packet.start_with?("\x7FFLAC")
-                 Ogg::FlacTag.new(identification_packet, comment_packet)
-        end
-      end
+      last_page = pages.to_a.last
+      pre_skip = @tag.respond_to?(:pre_skip) ? @tag.pre_skip : 0
 
-      def parse_duration
-        return @tag.duration if @tag.respond_to? :duration
-
-        last_page = pages.to_a.last
-        pre_skip = @tag.respond_to?(:pre_skip) ? @tag.pre_skip : 0
+      (last_page.granule_position - pre_skip) / @tag.sample_rate.to_f
+    end
 
-        ((last_page.granule_position - pre_skip) / @tag.sample_rate.to_f).round
-      end
+    def parse_bitrate
+      return @tag.bitrate if @tag.respond_to? :bitrate
+      ((file_size - @overhead_packets_size) * 8.0 / duration / 1000).round
+    end
 
-      def parse_bitrate
-        return @tag.bitrate if @tag.respond_to? :bitrate
-        ((file_size - @overhead_packets_size) * 8.0 / duration / 1000).round
-      end
+    def parse_bit_depth
+      @tag.bit_depth if @tag.respond_to? :bit_depth
+    end
   end
 end

data/lib/wahwah/riff/chunk.rb

@@ -16,39 +16,35 @@ module WahWah
     # 4 bytes: an ASCII identifier for this particular RIFF or LIST chunk (for RIFF in the typical case, these 4 bytes describe the content of the entire file, such as "AVI " or "WAVE").
     # rest of data: subchunks.
     class Chunk
+      prepend LazyRead
+
       HEADER_SIZE = 8
-      HEADER_FORMAT = 'A4V'
+      HEADER_FORMAT = "A4V"
       HEADER_TYPE_SIZE = 4
 
       attr_reader :id, :type
 
-      def initialize(file_io)
-        @id, @size = file_io.read(HEADER_SIZE)&.unpack(HEADER_FORMAT)
+      def initialize
+        @id, @size = @file_io.read(HEADER_SIZE)&.unpack(HEADER_FORMAT)
         return unless valid?
 
-        @type = file_io.read(HEADER_TYPE_SIZE).unpack('A4').first if have_type?
-        @file_io = file_io
-        @position = file_io.pos
+        @type = @file_io.read(HEADER_TYPE_SIZE).unpack1("A4") if have_type?
       end
 
       def size
-        @size = @size + 1 if @size.odd?
+        @size += 1 if @size.odd?
         have_type? ? @size - HEADER_TYPE_SIZE : @size
       end
 
-      def data
-        @file_io.seek(@position)
-        @file_io.read(size)
-      end
-
       def valid?
         !@id.empty? && !@size.nil? && @size > 0
       end
 
       private
-        def have_type?
-          %w(RIFF LIST).include? @id
-        end
+
+      def have_type?
+        %w[RIFF LIST].include? @id
+      end
     end
   end
 end