mp3file 0.0.2

data/lib/mp3file/id3v1_tag.rb

@@ -0,0 +1,58 @@
+module Mp3file
+  class InvalidID3v1TagError < Mp3fileError; end
+
+  class ID3v1Tag
+    attr_accessor(:title, :artist, :album, :year, :comment, :track, :genre)
+
+    class ID3v1TagFormat < BinData::Record
+      string(:tag_id, :length => 3, :check_value => lambda { value == 'TAG' })
+      string(:title, :length => 30)
+      string(:artist, :length => 30)
+      string(:album, :length => 30)
+      string(:year, :length => 4)
+      string(:comment, :length => 30)
+      uint8(:genre_id)
+    end
+
+    # First group is the original spec, the second are Winamp extensions.
+    GENRES = 
+      %w{ Blues Classic\ Rock Country Dance Disco Funk Grunge Hip-Hop Jazz 
+        Metal New\ Age Oldies Other Pop R&B Rap Reggae Rock Techno Industrial 
+        Alternative Ska Death\ Metal Pranks Soundtrack Euro-Techno Ambient Trip-Hop 
+        Vocal Jazz+Funk Fusion Trance Classical Instrumental Acid House Game 
+        Sound\ Clip Gospel Noise AlternRock Bass Soul Punk Space Meditative 
+        Instrumental\ Pop Instrumental\ Rock Ethnic Gothic Darkwave Techno-Industrial 
+        Electronic Pop-Folk Eurodance Dream Southern\ Rock Comedy Cult Gangsta 
+        Top\ 40 Christian\ Rap Pop/Funk Jungle Native\ American Cabaret New\ Wave 
+        Psychadelic Rave Showtunes Trailer Lo-Fi Tribal Acid\ Punk Acid\ Jazz Polka 
+        Retro Musical Rock\ &\ Roll Hard\ Rock 
+
+        Folk Folk-Rock National\ Folk Swing 
+        Fast\ Fusion Bebob Latin Revival Celtic Bluegrass Avantgarde Gothic\ Rock 
+        Progressive\ Rock Psychedelic\ Rock Symphonic\ Rock Slow\ Rock Big\ Band 
+        Chorus Easy\ Listening Acoustic Humour Speech Chanson Opera Chamber\ Music 
+        Sonata Symphony Booty\ Bass Primus Porn\ Groove Satire Slow\ Jam Club Tango 
+        Samba Folklore Ballad Power\ Ballad Rhythmic\ Soul Freestyle Duet Punk\ Rock 
+        Drum\ Solo A\ capella Euro-House Dance\ Hall }
+
+    def initialize(io)
+      @tag = nil
+      begin
+        @tag = ID3v1TagFormat.read(io)
+      rescue BinData::ValidityError => ve
+        raise InvalidID3v1TagError, ve.message
+      end
+
+      @title = @tag.title.split("\x00").first
+      @artist = @tag.artist.split("\x00").first
+      @album = @tag.album.split("\x00").first
+      @year = @tag.year
+      split_comment = @tag.comment.split("\x00").reject { |s| s == '' }
+      @comment = split_comment.first
+      if split_comment.size > 1
+        @track = split_comment.last.bytes.first
+      end
+      @genre = GENRES[@tag.genre_id]
+    end
+  end
+end

data/lib/mp3file/id3v2/bit_padded_int.rb

@@ -0,0 +1,24 @@
+module Mp3file::ID3v2
+  module BitPaddedInt
+    def self.unpad_number(num, bits = 7)
+      field = 2**bits - 1
+      rv = 0
+      0.upto(3) do |i|
+        rv += (num & field) >> (i*(8-bits))
+        field = field << 8
+      end
+      rv
+    end
+
+    def self.pad_number(num, bits = 7)
+      field = 2**bits - 1
+      num2 = num
+      rv = 0
+      0.upto(3) do |i|
+        rv += (num2 & field) << (i*8)
+        num2 = num2 >> bits
+      end
+      rv
+    end
+  end
+end

data/lib/mp3file/id3v2/frame_header.rb

@@ -0,0 +1,84 @@
+module Mp3file::ID3v2
+  class FrameHeader
+    class ID3v220FrameHeaderFormat < BinData::Record
+      string(:frame_id, :length => 3)
+      uint24be(:frame_size)
+    end
+
+    class ID3v230FrameHeaderFormat < BinData::Record
+      string(:frame_id, :length => 4)
+      uint32be(:frame_size)
+      bit1(:tag_alter_preserve)
+      bit1(:file_alter_preserve)
+      bit1(:read_only)
+      bit5(:unused1, :check_value => lambda { value == 0 })
+      bit1(:compression)
+      bit1(:encryption)
+      bit1(:has_group)
+      bit5(:unused2, :check_value => lambda { value == 0 })
+      uint8(:encryption_type, :onlyif => lambda { encryption == 1 })
+      uint8(:group_id, :onlyif => lambda { has_group == 1 })
+    end
+
+    class ID3v240FrameHeaderFormat < BinData::Record
+      string(:frame_id, :length => 4)
+      uint32be(:frame_size)
+      bit1(:unused1, :check_value => lambda { value == 0 })
+      bit1(:tag_alter_preserve)
+      bit1(:file_alter_preserve)
+      bit1(:read_only)
+      bit4(:unused2, :check_value => lambda { value == 0 })
+      bit1(:unused3, :check_value => lambda { value == 0 })
+      bit1(:group)
+      bit2(:unused4, :check_value => lambda { value == 0 })
+      bit1(:compression)
+      bit1(:encryption)
+      bit1(:unsynchronized)
+      bit1(:data_length_indicator)
+    end
+
+    attr_reader(:frame_id, :size,
+      :preserve_on_altered_tag, :preserve_on_altered_file,
+      :read_only, :compressed, :encrypted, :encryption_type,
+      :group, :unsynchronized, :data_length)
+
+    def initialize(io, tag)
+      @tag = tag
+      header = nil
+      @preserve_on_altered_tag = false
+      @preserve_on_altered_file = false
+      @read_only = false
+      @compressed = false
+      @encrypted = false
+      @group = nil
+      @unsynchronized = false
+      @data_length = 0
+
+      begin
+        if @tag.version >= ID3V2_2_0 && @tag.version < ID3V2_3_0
+          header = ID3v220FrameHeaderFormat.read(io)
+        elsif @tag.version >= ID3V2_3_0 && @tag.version < ID3V2_4_0
+          header = ID3v230FrameHeaderFormat.read(io)
+          @preserve_on_altered_tag = header.tag_alter_preserve == 1
+          @preserve_on_altered_file = header.file_alter_preserve == 1
+          @read_only = header.read_only == 1
+          @compressed = header.compression == 1
+          if header.encryption == 1
+            @encrypted = true
+            @encryption_type = header.encryption_type
+          end
+          if header.has_group == 1
+            @group = header.group_id
+          end
+        elsif @tag.version >= ID3V2_4_0
+          header = ID3v240FrameHeaderFormat.read(io)
+        end
+      rescue BinData::ValidityError => ve
+        raise InvalidID3v2TagError, ve.message
+      end
+
+      @frame_id = header.frame_id
+      @size = BitPaddedInt.unpad_number(header.frame_size)
+    end
+  end
+end

data/lib/mp3file/id3v2/header.rb

@@ -0,0 +1,67 @@
+module Mp3file::ID3v2
+  class Header
+    attr_reader(
+      :version, 
+      :unsynchronized, 
+      :extended_header, 
+      :compression,
+      :experimental, 
+      :footer, 
+      :tag_size)
+
+    class ID3v2HeaderFormat < BinData::Record
+      string(:tag_id, :length => 3, :check_value => lambda { value == 'ID3' })
+      uint8(:vmaj, :check_value => lambda { value >= 2 && value <= 4 })
+      uint8(:vmin)
+
+      bit1(:unsynchronized)
+      bit1(:extended_header)
+      bit1(:experimental)
+      bit1(:footer)
+      bit4(:unused, :check_value => lambda { value == 0 })
+
+      uint32be(:size_padded)
+    end
+
+    def initialize(io)
+      header = nil
+      begin
+        header = ID3v2HeaderFormat.read(io)
+      rescue BinData::ValidityError => ve
+        raise InvalidID3v2TagError, ve.message
+      end
+
+      @version = Version.new(header.vmaj, header.vmin)
+
+      @unsynchronized = false
+      @extended_header = false
+      @compression = false
+      @experimental = false
+      @footer = false
+
+      if @version >= ID3V2_2_0 && @version < ID3V2_3_0
+        @unsynchronized = header.unsynchronized == 1
+        # Bit 6 was redefined in v2.3.0+, and we picked the new name
+        # for it above.
+        @compression = header.extended_header == 1
+        if header.experimental == 1 || header.footer == 1
+          raise InvalidID3v2TagError, "Invalid flag set in ID3v2.2 header"
+        end
+      elsif @version >= ID3V2_3_0 && @version < ID3V2_4_0
+        @unsynchronized = header.unsynchronized == 1
+        @extended_header = header.extended_header == 1
+        @experimental = header.experimental == 1
+        if header.footer == 1
+          raise InvalidID3v2TagError, "Invalid flag set in ID3v2.3 header"
+        end
+      elsif @version >= ID3V2_4_0 
+        @unsynchronized = header.unsynchronized == 1
+        @extended_header = header.extended_header == 1
+        @experimental = header.experimental == 1
+        @footer = header.footer == 1
+      end
+
+      @tag_size = BitPaddedInt.unpad_number(header.size_padded)
+    end
+  end
+end

data/lib/mp3file/id3v2/tag.rb

@@ -0,0 +1,25 @@
+require 'forwardable'
+
+module Mp3file::ID3v2
+  class Tag
+    extend Forwardable
+
+    def_delegators(:@header, :version, :unsynchronized, :extended_header, 
+      :compression, :experimental, :footer)
+
+    attr_reader(:header, :frames)
+
+    def initialize(io)
+      @header = Header.new(io)
+      @frames = []
+    end
+
+    def load_frames
+      @frames = []
+    end
+
+    def size
+      @header.tag_size + 10
+    end
+  end
+end

data/lib/mp3file/id3v2/text_frame.rb

@@ -0,0 +1,4 @@
+module Mp3file::ID3v2
+  class TextFrame
+  end
+end

data/lib/mp3file/id3v2/version.rb

@@ -0,0 +1,40 @@
+module Mp3file::ID3v2
+  class Version
+    include Comparable
+
+    attr_reader(:vbig, :vmaj, :vmin)
+
+    def initialize(vmaj, vmin, vbig = 2)
+      @vbig = vbig.to_i
+      @vmaj = vmaj.to_i
+      @vmin = vmin.to_i
+    end
+
+    def <=>(other)
+      c = vbig <=> other.vbig
+      return c if c != 0
+
+      c = vmaj <=> other.vmaj
+      return c if c != 0
+
+      vmin <=> other.vmin
+    end
+
+    def to_s
+      "ID3v%d.%d.%d" % [ vbig, vmaj, vmin ]
+    end
+
+    def to_byte_string
+      [ vmaj, vmin ].pack("cc")
+    end
+
+    def inspect
+      "<%p vbig = %p vmaj = %p vmin = %p>" %
+        [ self.class, @vbig, @vmaj, @vmin ]
+    end
+  end
+
+  ID3V2_4_0 = Version.new(4, 0)
+  ID3V2_3_0 = Version.new(3, 0)
+  ID3V2_2_0 = Version.new(2, 0)
+end

data/lib/mp3file/id3v2.rb

@@ -0,0 +1,12 @@
+module Mp3file
+  module ID3v2
+    class InvalidID3v2TagError < Mp3fileError; end
+  end
+end
+
+require 'mp3file/id3v2/bit_padded_int'
+require 'mp3file/id3v2/version'
+require 'mp3file/id3v2/header'
+require 'mp3file/id3v2/tag'
+require 'mp3file/id3v2/frame_header'
+require 'mp3file/id3v2/text_frame'

data/lib/mp3file/mp3_file.rb

@@ -0,0 +1,182 @@
+module Mp3file
+  class MP3File
+    attr_reader(:file, :file_size, :audio_size)
+    attr_reader(:first_header_offset, :first_header)
+    attr_reader(:xing_header_offset, :xing_header)
+    attr_reader(:vbri_header_offset, :vbri_header)
+    attr_reader(:mpeg_version, :layer, :bitrate, :samplerate, :mode)
+    attr_reader(:num_frames, :total_samples, :length)
+
+    attr_accessor(:id3v1_tag)
+
+    def initialize(file_path)
+      file_path = Pathname.new(file_path).expand_path if file_path.is_a?(String)
+      load_file(file_path)
+    end
+
+    def vbr?
+      @vbr
+    end
+
+    def id3v1tag?
+      !@id3v1_tag.nil?
+    end
+
+    def id3v2tag?
+      !@id3v2_tag.nil?
+    end
+
+    def title
+      value_from_tags(:title)
+    end
+
+    def artist
+      value_from_tags(:artist)
+    end
+
+    def album
+      value_from_tags(:album)
+    end
+
+    def track
+      value_from_tags(:track)
+    end
+
+    def year
+      value_from_tags(:year)
+    end
+
+    def comment
+      value_from_tags(:comment)
+    end
+
+    def genre
+      value_from_tags(:genre)
+    end
+
+    private
+
+    def value_from_tags(v1_field)
+      if @id3v1_tag
+        @id3v1_tag.send(v1_field)
+      else
+        nil
+      end
+    end
+
+    def load_file(file_path)
+      @file = file_path.open('rb')
+      @file.seek(0, IO::SEEK_END)
+      @file_size = @file.tell
+
+      # Try to read an ID3v1 tag.
+      @id3v1_tag = nil
+      @file.seek(-128, IO::SEEK_END)
+      begin
+        @id3v1_tag = ID3v1Tag.new(@file)
+      rescue InvalidID3v1TagError => e
+        @id3v1_tag = nil
+      end
+      @file.seek(0, IO::SEEK_SET)
+
+      # Try to detect an ID3v2 header.
+      @id3v2_header = nil
+      begin
+        @id3v2_header = ID3v2::Header.new(@file)
+      rescue ID3v2::InvalidID3v2TagError => e
+        @id3v2_header = nil
+        @file.seek(0, IO::SEEK_SET)
+      end
+
+      # Skip past the ID3v2 header if it's present.
+      if @id3v2_header
+        @file.seek(@id3v2_header.tag_size + 10, IO::SEEK_SET)
+      end
+
+      # Try to find the first MP3 header.
+      @first_header_offset, @first_header = get_next_header(@file)
+
+      @mpeg_version = @first_header.version
+      @layer = @first_header.layer
+      @bitrate = @first_header.bitrate / 1000
+      @samplerate = @first_header.samplerate
+      @mode = @first_header.mode
+      @audio_size = @file_size
+      if @id3v1_tag
+        @audio_size -= 128
+      end
+      if @id3v2_header
+        @audio_size -= (@id3v2_header.tag_size + 10)
+      end
+
+      # If it's VBR, there should be an Xing header after the
+      # side_bytes.
+      @xing_header = nil
+      @file.seek(@first_header.side_bytes, IO::SEEK_CUR)
+      begin
+        @xing_header = XingHeader.new(@file)
+      rescue InvalidXingHeaderError => ve
+        @file.seek(@first_header_offset + 4, IO::SEEK_CUR)
+      end
+
+      if @xing_header
+        @vbr = true
+        # Do the VBR length calculation.  What to do if we don't have
+        # both of these pieces of information?
+        if @xing_header.frames && @xing_header.bytes
+          @num_frames = @xing_header.frames
+          @total_samples = @xing_header.frames * @first_header.samples
+          @length = total_samples / @samplerate
+          @bitrate = ((@xing_header.bytes.to_f / @length.to_f) * 8 / 1000).to_i
+        end
+      else
+        # Do the CBR length calculation.
+        @vbr = false
+        @num_frames = @audio_size / @first_header.frame_size
+        @total_samples = @num_frames * @first_header.samples
+        @length = @total_samples / @samplerate
+      end
+
+      @file.close
+    end
+
+    def get_next_header(file, offset = nil)
+      if offset && offset != file.tell
+        file.seek(offset, IO::SEEK_SET)
+      end
+
+      header = nil
+      header_offset = file.tell
+
+      while header.nil?
+        begin
+          header = MP3Header.new(file)
+          header_offset = file.tell - 4
+        rescue InvalidMP3HeaderError => e
+          header_offset += 1
+          file.seek(header_offset, IO::SEEK_SET)
+          retry
+        end
+
+        # byte = file.readbyte
+        # while byte != 0xFF
+        #   byte = file.readbyte
+        # end
+        # header_bytes = [ byte ] + file.read(3).bytes.to_a
+        # if header_bytes[1] & 0xE0 != 0xE0
+        #   file.seek(-3, IO::SEEK_CUR)
+        # else
+        #   header = MP3Header.new(header_bytes)
+        #   if !header.valid?
+        #     header = nil
+        #     file.seek(-3, IO::SEEK_CUR)
+        #   else
+        #     header_offset = file.tell - 4
+        #   end
+        # end
+      end
+
+      [ header_offset, header ]
+    end
+  end
+end

data/lib/mp3file/mp3_header.rb

@@ -0,0 +1,109 @@
+module Mp3file
+  class InvalidMP3HeaderError < Mp3fileError; end
+
+  class MP3Header
+    attr_reader(:version, :layer, :has_crc, :bitrate, 
+      :samplerate, :has_padding, :mode, :mode_extension, 
+      :copyright, :original, :emphasis, :samples, :frame_size,
+      :side_bytes)
+
+    class MP3HeaderFormat < BinData::Record
+      uint8(:sync1, :value => 255, :check_value => lambda { value == 255 })
+
+      bit3(:sync2, :value => 7, :check_value => lambda { value == 7 })
+      bit2(:version, :check_value => lambda { value != 1 })
+      bit2(:layer, :check_value => lambda { value != 0 })
+      bit1(:crc)
+
+      bit4(:bitrate, :check_value => lambda { value != 15 && value != 0 })
+      bit2(:samplerate, :check_value => lambda { value != 3 })
+      bit1(:padding)
+      bit1(:private)
+
+      bit2(:mode)
+      bit2(:mode_extension)
+      bit1(:copyright)
+      bit1(:original)
+      bit2(:emphasis, :check_value => lambda { value != 2 })
+    end
+
+    MPEG_VERSIONS = [ 'MPEG 2.5', nil, 'MPEG 2', 'MPEG 1' ]
+    LAYERS = [ nil, 'Layer III', 'Layer II', 'Layer I' ]
+    BITRATES = [
+      # MPEG 2.5
+      [ nil,
+        [  8, 16, 24, 32, 40, 48,  56,  64,  80,  96, 112, 128, 144, 160 ],    # Layer III
+        [  8, 16, 24, 32, 40, 48,  56,  64,  80,  96, 112, 128, 144, 160 ],    # Layer II
+        [ 32, 48, 56, 64, 80, 96, 112, 128, 144, 160, 176, 192, 224, 256 ], ], # Layer I
+      # reserved
+      nil,
+      # MPEG 2
+      [ nil,
+        [  8, 16, 24, 32, 40, 48,  56,  64,  80,  96, 112, 128, 144, 160 ],    # Layer III
+        [  8, 16, 24, 32, 40, 48,  56,  64,  80,  96, 112, 128, 144, 160 ],    # Layer II
+        [ 32, 48, 56, 64, 80, 96, 112, 128, 144, 160, 176, 192, 224, 256 ], ], # Layer I
+      # MPEG 1
+      [ nil,
+        [ 32, 40, 48,  56,  64,  80,  96, 112, 128, 160, 192, 224, 256, 320 ],   # Layer III
+        [ 32, 48, 56,  64,  80,  96, 112, 128, 160, 192, 224, 256, 320, 384 ],   # Layer II
+        [ 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448 ], ] # Layer I
+    ]
+    SAMPLERATES = [
+      [ 11025, 12000,  8000 ], # MPEG 2.5
+      nil,
+      [ 22050, 24000, 16000 ], # MPEG 2
+      [ 44100, 48000, 32000 ], # MPEG 1
+    ]
+    MODES = [ 'Stereo', 'Joint Stereo', 'Dual Channel', 'Mono' ]
+    SAMPLE_COUNTS = [
+      [ nil,  576, 1152, 384 ], # MPEG 2.5, III / II / I
+      nil,
+      [ nil,  576, 1152, 384 ], # MPEG 2, III / II / I
+      [ nil, 1152, 1152, 384 ], # MPEG 1, III / II / I
+    ]
+    SIDE_BYTES = [
+      [ 17, 17, 17,  9 ], # MPEG 2.5, Stereo, J-Stereo, Dual Channel, Mono
+      nil,
+      [ 17, 17, 17,  9 ], # MPEG 2, Stereo, J-Stereo, Dual Channel, Mono
+      [ 32, 32, 32, 17 ], # MPEG 1, Stereo, J-Stereo, Dual Channel, Mono
+    ]
+    MODE_EXTENSIONS_LAYER_I_II = [ 'bands 4 to 31', 'bands 8 to 31', 'bands 12 to 31', 'bands 16 to 31' ]
+    MODE_EXTENSIONS_LAYER_III = [ nil, 'Intensity Stereo', 'M/S Stereo', [ 'Intensity Stereo', 'M/S Stereo' ] ]
+    EMPHASES = [ 'none', '50/15 ms', nil, 'CCIT J.17' ]
+
+    def initialize(io)
+      begin
+        head = MP3HeaderFormat.read(io)
+      rescue BinData::ValidityError => ve
+        raise InvalidMP3HeaderError, ve.message
+      end
+
+      @version = MPEG_VERSIONS[head.version]
+      @layer = LAYERS[head.layer]
+      @has_crc = head.crc == 0
+      @bitrate = BITRATES[head.version][head.layer][head.bitrate - 1] * 1000
+      @samplerate = SAMPLERATES[head.version][head.samplerate]
+      @has_padding = head.padding == 1
+      @mode = MODES[head.mode]
+
+      @mode_extension = nil
+      if @mode == 'Joint Stereo'
+        if [ 'Layer I', 'Layer II' ].include?(@layer)
+          @mode_extension = MODE_EXTENSIONS_LAYER_I_II[head.mode_extension]
+        elsif @layer == 'Layer III'
+          @mode_extension = MODE_EXTENSIONS_LAYER_III[head.mode_extension]
+        end
+      end
+
+      @copyright = head.copyright == 1
+      @original = head.original == 1
+      @emphasis = EMPHASES[head.emphasis]
+      @samples = SAMPLE_COUNTS[head.version][head.layer]
+
+      slot_size = layer == 'Layer I' ? 4 : 1
+      pad_slots = has_padding ? 1 : 0
+      @frame_size = (((samples.to_f * bitrate.to_f) / (8 * slot_size.to_f * samplerate.to_f)) + pad_slots).to_i * slot_size
+      @side_bytes = SIDE_BYTES[head.version][head.mode]
+    end
+  end
+end

data/lib/mp3file/version.rb

@@ -0,0 +1,3 @@
+module Mp3file
+  VERSION = "0.0.2"
+end

data/lib/mp3file/xing_header.rb

@@ -0,0 +1,39 @@
+module Mp3file
+  class InvalidXingHeaderError < Mp3fileError; end
+
+  class XingHeader
+    attr_reader(:frames, :bytes, :toc, :quality)
+
+    class XingHeaderFormat < BinData::Record
+      string(:vbr_id, :length => 4, :check_value => lambda { value == 'Xing' })
+
+      uint8(:unused1, :check_value => lambda { value == 0 })
+      uint8(:unused2, :check_value => lambda { value == 0 })
+      uint8(:unused3, :check_value => lambda { value == 0 })
+      bit4(:unused4, :check_value => lambda { value == 0 })
+      bit1(:quality_present)
+      bit1(:toc_present)
+      bit1(:bytes_present)
+      bit1(:frames_present)
+
+      uint32be(:frames, :onlyif => lambda { frames_present == 1 })
+      uint32be(:bytes, :onlyif => lambda { bytes_present == 1 })
+      array(:toc, :type => :uint8, :read_until => lambda { index == 99 }, :onlyif => lambda { toc_present == 1 })
+      uint32be(:quality, :onlyif => lambda { quality_present == 1 })
+    end
+
+    def initialize(io)
+      head = nil
+      begin
+        head = XingHeaderFormat.read(io)
+      rescue BinData::ValidityError => ve
+        raise InvalidXingHeaderError, ve.message
+      end
+
+      @frames = head.frames if head.frames_present == 1
+      @bytes = head.bytes if head.bytes_present == 1
+      @toc = head.toc.dup if head.toc_present == 1
+      @quality = head.quality if head.quality_present == 1
+    end
+  end
+end

data/lib/mp3file.rb

@@ -0,0 +1,12 @@
+require 'pathname'
+
+require 'rubygems'
+require 'bindata'
+
+class Mp3fileError < StandardError; end
+
+require 'mp3file/mp3_file'
+require 'mp3file/mp3_header'
+require 'mp3file/xing_header'
+require 'mp3file/id3v1_tag'
+require 'mp3file/id3v2'

data/mp3file.gemspec

@@ -0,0 +1,26 @@
+# -*- mode: ruby; encoding: utf-8 -*-
+
+$:.push File.expand_path("../lib", __FILE__)
+require "mp3file/version"
+
+Gem::Specification.new do |s|
+  s.name        = "mp3file"
+  s.version     = Mp3file::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Andrew Watts"]
+  s.email       = ["ahwatts@gmail.com"]
+  s.homepage    = "http://rubygems.org/gems/mp3file"
+  s.summary     = %q{Reads MP3 headers and returns their information.}
+  s.description = %q{Reads MP3 headers and returns their information.}
+
+  s.rubyforge_project = "mp3file"
+
+  s.add_development_dependency('rspec')
+  s.add_development_dependency('rake')
+  s.add_dependency('bindata')
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end