wahwah 0.1.0.pre.test

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c4f8d14cd1c6aa34326a6b0bb4e5ac8bed06778a7b981ca0accb86214f7ad9ee
+  data.tar.gz: 0763f36ffc903dc02dd47b885c71e11df3248aa3bc513d53d78c41e7f149cda0
+SHA512:
+  metadata.gz: 2570bfd1bdaa7705048d23f9e5a89b3f954817b48d2a520ca93901a5b7cad34e32eafa9d46f4d4bb97b371b82fcd1df463ac96a698a10043b65ecc07d470cff1
+  data.tar.gz: 045d228d65fbadbe5363a916897f2b812df0e6d2e0fc94e4dc9cd6e09c7f737ad00a96add2fa52564c5c813e6d588e0d4fd1f6d8dfc4b3ed80f4662dee1b68e3

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Aidewoode <aidewoode@gmail.com>
+
+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/lib/wahwah.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require 'wahwah/version'
+require 'wahwah/errors'
+require 'wahwah/helper'
+require 'wahwah/tag_delegate'
+require 'wahwah/tag'
+
+require 'wahwah/id3/v1'
+require 'wahwah/id3/v2'
+require 'wahwah/id3/v2_header'
+require 'wahwah/id3/frame'
+require 'wahwah/id3/frame_body'
+require 'wahwah/id3/text_frame_body'
+require 'wahwah/id3/genre_frame_body'
+require 'wahwah/id3/comment_frame_body'
+require 'wahwah/id3/image_frame_body'
+
+require 'wahwah/mp3/mpeg_frame_header'
+require 'wahwah/mp3/xing_header'
+require 'wahwah/mp3/vbri_header'
+
+require 'wahwah/riff/chunk'
+
+require 'wahwah/flac/block'
+require 'wahwah/flac/streaminfo_block'
+
+require 'wahwah/ogg/page'
+require 'wahwah/ogg/pages'
+require 'wahwah/ogg/packets'
+require 'wahwah/ogg/vorbis_comment'
+require 'wahwah/ogg/vorbis_tag'
+require 'wahwah/ogg/opus_tag'
+require 'wahwah/ogg/flac_tag'
+
+require 'wahwah/asf/object'
+
+require 'wahwah/mp4/atom'
+
+require 'wahwah/mp3_tag'
+require 'wahwah/mp4_tag'
+require 'wahwah/ogg_tag'
+require 'wahwah/riff_tag'
+require 'wahwah/asf_tag'
+require 'wahwah/flac_tag'
+
+module WahWah
+  FORMATE_MAPPING = {
+    Mp3Tag: ['mp3'],
+    OggTag: ['ogg', 'oga', 'opus'],
+    RiffTag: ['wav'],
+    FlacTag: ['flac'],
+    AsfTag: ['wma'],
+    Mp4Tag: ['m4a']
+  }.freeze
+
+  def self.open(file_path)
+    file_path = file_path.to_path if file_path.respond_to? :to_path
+    file_path = file_path.to_str
+
+    file_format = Helper.file_format(file_path)
+
+    raise WahWahArgumentError, 'File is not exists' unless File.exist? file_path
+    raise WahWahArgumentError, 'File is unreadable' unless File.readable? file_path
+    raise WahWahArgumentError, 'File is empty' unless File.size(file_path) > 0
+    raise WahWahArgumentError, 'No supported format found' unless support_formats.include? file_format
+
+    FORMATE_MAPPING.each do |tag, formats|
+      break const_get(tag).new(file_path) if formats.include?(file_format)
+    end
+  end
+
+  def self.support_formats
+    FORMATE_MAPPING.values.flatten
+  end
+end

data/lib/wahwah/asf/object.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module WahWah
+  module Asf
+    # The base unit of organization for ASF files is called the ASF object.
+    # It consists of a 128-bit GUID for the object, a 64-bit integer object size, and the variable-length object data.
+    # The value of the object size field is the sum of 24 bytes plus the size of the object data in bytes.
+    # The following diagram illustrates the ASF object structure:
+    #
+    # 16 bytes: Object GUID
+    # 8 bytes: Object size
+    # variable-sized: Object data
+    class Object
+      HEADER_SIZE = 24
+      HEADER_FORMAT = 'a16Q<'
+
+      attr_reader :size, :guid
+
+      def initialize(file_io)
+        guid_bytes, @size = file_io.read(HEADER_SIZE)&.unpack(HEADER_FORMAT)
+        return unless valid?
+
+        @size = @size - HEADER_SIZE
+        @guid = Helper.byte_string_to_guid(guid_bytes)
+        @file_io = file_io
+        @position = file_io.pos
+      end
+
+      def valid?
+        !@size.nil? && @size >= HEADER_SIZE
+      end
+
+      def data
+        @file_io.seek(@position)
+        @file_io.read(size)
+      end
+    end
+  end
+end

data/lib/wahwah/asf_tag.rb

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+module WahWah
+  class AsfTag < Tag
+    HEADER_OBJECT_CONTENT_SIZE = 6
+    HEADER_OBJECT_GUID = '75B22630-668E-11CF-A6D9-00AA0062CE6C'
+    FILE_PROPERTIES_OBJECT_GUID = '8CABDCA1-A947-11CF-8EE4-00C00C205365'
+    EXTENDED_CONTENT_DESCRIPTION_OBJECT_GUID = 'D2D0A440-E307-11D2-97F0-00A0C95EA850'
+    STREAM_PROPERTIES_OBJECT_GUID = 'B7DC0791-A9B7-11CF-8EE6-00C00C205365'
+    AUDIO_MEDIA_OBJECT_GUID = 'F8699E40-5B4D-11CF-A8FD-00805F5C442B'
+    CONTENT_DESCRIPTION_OBJECT_GUID = '75B22633-668E-11CF-A6D9-00AA0062CE6C'
+
+    EXTENDED_CONTENT_DESCRIPTOR_NAME_MAPPING = {
+      'WM/AlbumArtist' => :albumartist,
+      'WM/AlbumTitle' => :album,
+      'WM/Composer' => :composer,
+      'WM/Genre' => :genre,
+      'WM/PartOfSet' => :disc,
+      'WM/TrackNumber' => :track,
+      'WM/Year' => :year
+    }
+
+    private
+      # ASF files are logically composed of three types of top-level objects:
+      # the Header Object, the Data Object, and the Index Object(s).
+      # The Header Object is mandatory and must be placed at the beginning of every ASF file.
+      # Of the three top-level ASF objects, the Header Object is the only one that contains other ASF objects.
+      # All Unicode strings in ASF uses UTF-16, little endian, and the Byte-Order Marker (BOM) character is not present.
+      def parse
+        header_object = Asf::Object.new(@file_io)
+        return unless header_object.valid?
+
+        total_header_object_size = header_object.size + Asf::Object::HEADER_SIZE
+
+        return unless header_object.guid == HEADER_OBJECT_GUID
+
+        # Header Object contains 6 bytes useless data, so skip it.
+        @file_io.seek(HEADER_OBJECT_CONTENT_SIZE, IO::SEEK_CUR)
+
+        until total_header_object_size <= @file_io.pos
+          sub_object = Asf::Object.new(@file_io)
+          parse_sub_object(sub_object)
+        end
+      end
+
+      def parse_sub_object(sub_object)
+        case sub_object.guid
+        when FILE_PROPERTIES_OBJECT_GUID
+          parse_file_properties_object(sub_object)
+        when EXTENDED_CONTENT_DESCRIPTION_OBJECT_GUID
+          parse_extended_content_description_object(sub_object)
+        when STREAM_PROPERTIES_OBJECT_GUID
+          parse_stream_properties_object(sub_object)
+        when CONTENT_DESCRIPTION_OBJECT_GUID
+          parse_content_description_object(sub_object)
+        else
+          @file_io.seek(sub_object.size, IO::SEEK_CUR)
+        end
+      end
+
+      # File Properties Object structure:
+      #
+      # Field name                Field type  Size (bits)
+      #
+      # Object ID                 GUID        128
+      # Object Size               QWORD       64
+      # File ID                   GUID        128
+      # File Size                 QWORD       64
+      # Creation Date             QWORD       64
+      # Data Packets Count        QWORD       64
+      # Play Duration             QWORD       64
+      # Send Duration             QWORD       64
+      # Preroll                   QWORD       64
+      # Flags                     DWORD       32
+      #   Broadcast Flag                      1 (LSB)
+      #   Seekable Flag                       1
+      #   Reserved                            30
+      # Minimum Data Packet Size  DWORD       32
+      # Maximum Data Packet Size  DWORD       32
+      # Maximum Bitrate DWORD                 32
+      #
+      # Play Duration Specifies the time needed to play the file in 100-nanosecond units.
+      # The value of this field is invalid if the Broadcast Flag bit in the Flags field is set to 1.
+      #
+      # Preroll Specifies the amount of time to buffer data before starting to play the file, in millisecond units.
+      # If this value is nonzero, the Play Duration field and all of the payload Presentation Time fields have been offset by this amount.
+      def parse_file_properties_object(object)
+        play_duration, preroll, flags = object.data.unpack('x40Q<x8Q<b32')
+        @duration = (play_duration / 10000000.0 - preroll / 1000.0).round if flags[0] == '0'
+      end
+
+      # Extended Content Description Object structure:
+      #
+      # Field name                 Field type  Size (bits)
+      #
+      # Object ID                  GUID       128
+      # Object Size                QWORD      64
+      # Content Descriptors Count  WORD       16
+      # Content Descriptors        See text   varies
+      #
+      #
+      # The structure of each Content Descriptor:
+      #
+      # Field Name                  Field Type  Size (bits)
+      #
+      # Descriptor Name Length      WORD        16
+      # Descriptor Name             WCHAR       varies
+      # Descriptor Value Data Type  WORD        16
+      # Descriptor Value Length     WORD        16
+      # Descriptor Value            See text    varies
+      #
+      #
+      # Specifies the type of data stored in the Descriptor Value field.
+      # The types are defined in the following table.
+      #
+      # Value Type  Descriptor value  length
+      #
+      # 0x0000      Unicode string    varies
+      # 0x0001      BYTE array        varies
+      # 0x0002      BOOL              32
+      # 0x0003      DWORD             32
+      # 0x0004      QWORD             64
+      # 0x0005      WORD              16
+      def parse_extended_content_description_object(object)
+        object_data = StringIO.new(object.data)
+        descriptors_count = object_data.read(2).unpack('v').first
+
+        descriptors_count.times do
+          name_length = object_data.read(2).unpack('v').first
+          name = Helper.encode_to_utf8(object_data.read(name_length), source_encoding: 'UTF-16LE')
+          value_type, value_length = object_data.read(4).unpack('vv')
+          value = object_data.read(value_length)
+
+          attr_value = case value_type
+                       when 0
+                         Helper.encode_to_utf8(value, source_encoding: 'UTF-16LE')
+                       when 1
+                         value
+                       when 2, 3
+                         value.unpack('V').first
+                       when 4
+                         value.unpack('Q<').first
+                       when 5
+                         value.unpack('v').first
+          end
+
+          attr_name = EXTENDED_CONTENT_DESCRIPTOR_NAME_MAPPING[name]
+          instance_variable_set("@#{attr_name}", attr_value) unless attr_name.nil?
+        end
+      end
+
+      # Stream Properties Object structure:
+      #
+      # Field Name                    Field Type  Size (bits)
+      # Object ID                     GUID        128
+      # Object Size                   QWORD       64
+      # Stream Type                   GUID        128
+      # Error Correction Type         GUID        128
+      # Time Offset                   QWORD       64
+      # Type-Specific Data Length     DWORD       32
+      # Error Correction Data Length  DWORD       32
+      # Flags                         WORD        16
+      #   Stream Number                           7 (LSB)
+      #   Reserved                                8
+      #   Encrypted Content Flag                  1
+      # Reserved                      DWORD       32
+      # Type-Specific Data            BYTE        varies
+      # Error Correction Data         BYTE        varies
+      #
+      # Stream Type specifies the type of the stream (for example, audio, video, and so on).
+      # Any streams with unrecognized Stream Type values should be ignored.
+      #
+      # Audio media type Object structure:
+      #
+      # Field name                          Field type  Size (bits)
+      #
+      # Codec ID / Format Tag               WORD        16
+      # Number of Channels                  WORD        16
+      # Samples Per Second                  DWORD       32
+      # Average Number of Bytes Per Second  DWORD       32
+      # Block Alignment                     WORD        16
+      # Bits Per Sample                     WORD        16
+      def parse_stream_properties_object(object)
+        object_data = StringIO.new(object.data)
+        stream_type, type_specific_data_length = object_data.read(54).unpack('a16x24V')
+        stream_type_guid = Helper.byte_string_to_guid(stream_type)
+
+        return unless stream_type_guid == AUDIO_MEDIA_OBJECT_GUID
+
+        @sample_rate, bytes_per_second = object_data.read(type_specific_data_length).unpack('x4VV')
+        @bitrate = (bytes_per_second * 8.0 / 1000).round
+      end
+
+      # Content Description Object structure:
+      #
+      # Field name          Field type  Size (bits)
+      #
+      # Object ID           GUID        128
+      # Object Size         QWORD       64
+      # Title Length        WORD        16
+      # Author Length       WORD        16
+      # Copyright Length    WORD        16
+      # Description Length  WORD        16
+      # Rating Length       WORD        16
+      # Title               WCHAR       Varies
+      # Author              WCHAR       Varies
+      # Copyright           WCHAR       Varies
+      # Description         WCHAR       Varies
+      # Rating              WCHAR       Varies
+      def parse_content_description_object(object)
+        object_data = StringIO.new(object.data)
+        title_length, author_length, copyright_length, description_length, _ = object_data.read(10).unpack('v' * 5)
+
+        @title = Helper.encode_to_utf8(object_data.read(title_length), source_encoding: 'UTF-16LE')
+        @artist = Helper.encode_to_utf8(object_data.read(author_length), source_encoding: 'UTF-16LE')
+        object_data.seek(copyright_length, IO::SEEK_CUR)
+        @comments.push(Helper.encode_to_utf8(object_data.read(description_length), source_encoding: 'UTF-16LE'))
+      end
+  end
+end

data/lib/wahwah/errors.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module WahWah
+  class WahWahArgumentError < ArgumentError; end
+  class WahWahNotImplementedError < NotImplementedError; end
+end

data/lib/wahwah/flac/block.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module WahWah
+  module Flac
+    class Block
+      HEADER_SIZE = 4
+      HEADER_FORMAT = 'B*'
+      BLOCK_TYPE_INDEX = %w(STREAMINFO PADDING APPLICATION SEEKTABLE VORBIS_COMMENT CUESHEET PICTURE)
+
+      attr_reader :size, :type
+
+      def initialize(file_io)
+        # Block header structure:
+        #
+        # Length(bit)  Meaning
+        #
+        # 1            Last-metadata-block flag:
+        #              '1' if this block is the last metadata block before the audio blocks, '0' otherwise.
+        #
+        # 7            BLOCK_TYPE
+        #              0 : STREAMINFO
+        #              1 : PADDING
+        #              2 : APPLICATION
+        #              3 : SEEKTABLE
+        #              4 : VORBIS_COMMENT
+        #              5 : CUESHEET
+        #              6 : PICTURE
+        #              7-126 : reserved
+        #              127 : invalid, to avoid confusion with a frame sync code
+        #
+        # 24           Length (in bytes) of metadata to follow
+        #              (does not include the size of the METADATA_BLOCK_HEADER)
+        header_bits = file_io.read(HEADER_SIZE).unpack(HEADER_FORMAT).first
+
+        @last_flag = header_bits[0]
+        @type = BLOCK_TYPE_INDEX[header_bits[1..7].to_i(2)]
+        @size = header_bits[8..-1].to_i(2)
+
+        @file_io = file_io
+        @position = file_io.pos
+      end
+
+      def valid?
+        @size > 0
+      end
+
+      def is_last?
+        @last_flag.to_i == 1
+      end
+
+      def data
+        @file_io.seek(@position)
+        @file_io.read(size)
+      end
+    end
+  end
+end

data/lib/wahwah/flac/streaminfo_block.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module WahWah
+  module Flac
+    module StreaminfoBlock
+      STREAMINFO_BLOCK_SIZE = 34
+
+      # STREAMINFO block data structure:
+      #
+      # Length(bit)  Meaning
+      #
+      # 16           The minimum block size (in samples) used in the stream.
+      #
+      # 16           The maximum block size (in samples) used in the stream.
+      #              (Minimum blocksize == maximum blocksize) implies a fixed-blocksize stream.
+      #
+      # 24           The minimum frame size (in bytes) used in the stream.
+      #              May be 0 to imply the value is not known.
+      #
+      # 24          The maximum frame size (in bytes) used in the stream.
+      #              May be 0 to imply the value is not known.
+      #
+      # 20           Sample rate in Hz. Though 20 bits are available,
+      #              the maximum sample rate is limited by the structure of frame headers to 655350Hz.
+      #              Also, a value of 0 is invalid.
+      #
+      # 3            (number of channels)-1. FLAC supports from 1 to 8 channels
+      #
+      # 5            (bits per sample)-1. FLAC supports from 4 to 32 bits per sample.
+      #              Currently the reference encoder and decoders only support up to 24 bits per sample.
+      #
+      # 36           Total samples in stream. 'Samples' means inter-channel sample,
+      #              i.e. one second of 44.1Khz audio will have 44100 samples regardless of the number of channels.
+      #              A value of zero here means the number of total samples is unknown.
+      #
+      # 128          MD5 signature of the unencoded audio data.
+      def parse_streaminfo_block(block_data)
+        return unless block_data.size == STREAMINFO_BLOCK_SIZE
+
+        info_bits = block_data.unpack('x10B64').first
+
+        @sample_rate = info_bits[0..19].to_i(2)
+        bits_per_sample = info_bits[23..27].to_i(2) + 1
+        total_samples = info_bits[28..-1].to_i(2)
+
+        @duration = (total_samples.to_f / @sample_rate).round if @sample_rate > 0
+        @bitrate =  @sample_rate * bits_per_sample / 1000
+      end
+    end
+  end
+end