wahwah 0.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4f0442dc7cdc627cfe026cd772f5c244089b4d3ab0ac2c1343381b4462efe7de
-  data.tar.gz: 69f88a13f1e4aa4df4e76f9ab25d698448468176f74023ee6f9cdc7018236811
+  metadata.gz: 9db3f9953fd6a1641859fa4d27912ed6fdd1eec6b5a137498e1d7fa669903ea4
+  data.tar.gz: 23f36dddc181188c98d77a546960273ed6dd4c1f2dc548d0214cc3f2feeac060
 SHA512:
-  metadata.gz: 2ee68cdad4790218492dbd49545a421a6be8ccdc006ca0eb20254f2f0c083f11b580b5c39778af899e01a341136a84203e89e6f6eb55df3f9ce3d584d364ea24
-  data.tar.gz: 9493abddeaa6997bd6368e83b3ff225dd579ecfd3a29780cab227aec6a9aefab025cdae73a9684093c5a3ea9fb9559bdcab0e4723ca2326e07ae721a23d11f87
+  metadata.gz: 31171f19be0c4777e0fdcaa03c8d02449856847eb205e5867f0d76f0c8e44b221e98c3808834623e4bd943c4f94b8728fef17c0ebc91f3371a5fb2ce636cb5a4
+  data.tar.gz: 810d6c29379773f93e61d905be863fbda4eb1b0fa0127b10e52d9357bf1faa267df71f0bebf09d8652733e73c057eecc5e2fd5aea3da2500ac496aa3cb9a774e

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/asf/object.rb

@@ -0,0 +1,34 @@
+# 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
+      prepend LazyRead
+
+      HEADER_SIZE = 24
+      HEADER_FORMAT = "a16Q<"
+
+      attr_reader :guid
+
+      def initialize
+        guid_bytes, @size = @file_io.read(HEADER_SIZE)&.unpack(HEADER_FORMAT)
+        return unless valid?
+
+        @size -= HEADER_SIZE
+        @guid = Helper.byte_string_to_guid(guid_bytes)
+      end
+
+      def valid?
+        !@size.nil? && @size >= HEADER_SIZE
+      end
+    end
+  end
+end

data/lib/wahwah/asf_tag.rb

@@ -0,0 +1,221 @@
+# 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
+        sub_object.skip
+      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 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).unpack1("v")
+
+      descriptors_count.times do
+        name_length = object_data.read(2).unpack1("v")
+        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.unpack1("V")
+                     when 4
+                       value.unpack1("Q<")
+                     when 5
+                       value.unpack1("v")
+        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, @bit_depth = object_data.read(type_specific_data_length).unpack("x4VVx2v")
+      @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,7 @@
+# frozen_string_literal: true
+
+module WahWah
+  class WahWahArgumentError < ArgumentError; end
+
+  class WahWahNotImplementedError < RuntimeError; end
+end

data/lib/wahwah/flac/block.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module WahWah
+  module Flac
+    class Block
+      prepend LazyRead
+
+      HEADER_SIZE = 4
+      HEADER_FORMAT = "B*"
+      BLOCK_TYPE_INDEX = %w[STREAMINFO PADDING APPLICATION SEEKTABLE VORBIS_COMMENT CUESHEET PICTURE]
+
+      attr_reader :type
+
+      def initialize
+        # 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).unpack1(HEADER_FORMAT)
+
+        @last_flag = header_bits[0]
+        @type = BLOCK_TYPE_INDEX[header_bits[1..7].to_i(2)]
+        @size = header_bits[8..].to_i(2)
+      end
+
+      def valid?
+        @size > 0
+      end
+
+      def is_last?
+        @last_flag.to_i == 1
+      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.unpack1("x10B64")
+
+        @sample_rate = info_bits[0..19].to_i(2)
+        @bit_depth = info_bits[23..27].to_i(2) + 1
+        total_samples = info_bits[28..].to_i(2)
+
+        @duration = total_samples.to_f / @sample_rate if @sample_rate > 0
+        @bitrate = @sample_rate * @bit_depth / 1000
+      end
+    end
+  end
+end

data/lib/wahwah/flac_tag.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module WahWah
+  class FlacTag < Tag
+    include Ogg::VorbisComment
+    include Flac::StreaminfoBlock
+
+    TAG_ID = "fLaC"
+
+    private
+
+    # FLAC structure:
+    #
+    # The four byte string "fLaC"
+    # The STREAMINFO metadata block
+    # Zero or more other metadata blocks
+    # One or more audio frames
+    def parse
+      # Flac file maybe contain ID3 header on the start, so skip it if exists
+      id3_header = ID3::V2Header.new(@file_io)
+      id3_header.valid? ? @file_io.seek(id3_header.size) : @file_io.rewind
+
+      return if @file_io.read(4) != TAG_ID
+
+      loop do
+        block = Flac::Block.new(@file_io)
+        parse_block(block)
+
+        break if block.is_last? || @file_io.eof?
+      end
+    end
+
+    def parse_block(block)
+      return unless block.valid?
+
+      case block.type
+      when "STREAMINFO"
+        parse_streaminfo_block(block.data)
+      when "VORBIS_COMMENT"
+        parse_vorbis_comment(block.data)
+      when "PICTURE"
+        @images_data.push(block)
+        block.skip
+      else
+        block.skip
+      end
+    end
+
+    # PICTURE block data structure:
+    #
+    # Length(bit)  Meaning
+    #
+    # 32           The picture type according to the ID3v2 APIC frame:
+    #
+    # 32           The length of the MIME type string in bytes.
+    #
+    # n*8          The MIME type string.
+    #
+    # 32           The length of the description string in bytes.
+    #
+    # n*8          The description of the picture, in UTF-8.
+    #
+    # 32           The width of the picture in pixels.
+    #
+    # 32           The height of the picture in pixels.
+    #
+    # 32           The color depth of the picture in bits-per-pixel.
+    #
+    # 32           For indexed-color pictures (e.g. GIF), the number of colors used, or 0 for non-indexed pictures.
+    #
+    # 32           The length of the picture data in bytes.
+    #
+    # n*8          The binary picture data.
+    def parse_image_data(picture_block)
+      block_content = StringIO.new(picture_block.data)
+
+      type_index, mime_type_length = block_content.read(8).unpack("NN")
+      mime_type = Helper.encode_to_utf8(block_content.read(mime_type_length))
+      description_length = block_content.read(4).unpack1("N")
+      data_length = block_content.read(description_length + 20).unpack1("#{"x" * (description_length + 16)}N")
+      data = block_content.read(data_length)
+
+      {data: data, mime_type: mime_type, type: ID3::ImageFrameBody::TYPES[type_index]}
+    end
+  end
+end

data/lib/wahwah/helper.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module WahWah
+  module Helper
+    def self.encode_to_utf8(string, source_encoding: "")
+      encoded_string = source_encoding.empty? ?
+        string.force_encoding("utf-8") :
+        string.encode("utf-8", source_encoding, invalid: :replace, undef: :replace, replace: "")
+
+      encoded_string.valid_encoding? ? encoded_string.strip : ""
+    end
+
+    # ID3 size is encoded with four bytes where may the most significant
+    # bit (bit 7) is set to zero in every byte,
+    # making a total of 28 bits. The zeroed bits are ignored
+    def self.id3_size_caculate(bits_string, has_zero_bit: true)
+      if has_zero_bit
+        bits_string.scan(/.{8}/).map { |byte_string| byte_string[1..] }.join.to_i(2)
+      else
+        bits_string.to_i(2)
+      end
+    end
+
+    def self.split_with_terminator(string, terminator_size)
+      string.split(Regexp.new(('\x00' * terminator_size).b), 2)
+    end
+
+    def self.file_format(file_path)
+      File.extname(file_path).downcase.delete(".")
+    end
+
+    def self.byte_string_to_guid(byte_string)
+      guid = byte_string.unpack("NnnA*").pack("VvvA*").unpack1("H*")
+      [guid[0..7], guid[8..11], guid[12..15], guid[16..19], guid[20..]].join("-").upcase
+    end
+  end
+end

data/lib/wahwah/id3/comment_frame_body.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module WahWah
+  module ID3
+    class CommentFrameBody < FrameBody
+      # Comment frame body structure:
+      #
+      # Text encoding             $xx
+      # Language                  $xx xx xx
+      # Short content description <textstring> $00 (00)
+      # The actual text           <textstring>
+      def parse
+        encoding_id, _language, reset_content = @content.unpack("CA3a*")
+        encoding = ENCODING_MAPPING[encoding_id]
+        _description, comment_text = Helper.split_with_terminator(reset_content, ENCODING_TERMINATOR_SIZE[encoding])
+
+        @value = Helper.encode_to_utf8(comment_text, source_encoding: encoding)
+      end
+    end
+  end
+end