riffy 0.1.0

data/lib/chunk.rb

@@ -0,0 +1,63 @@
+require_relative 'four_cc'
+require_relative 'chunk_data'
+
+class Chunk < Struct.new(:id, :size, :data)
+
+  # MIN_SIZE = "\x00\x00\x00\x00".unpack("L<")
+  # MAX_SIZE = "\xFF\xFF\xFF\xFF".unpack("L<")
+  
+  def initialize(file)
+  
+    self.id = file.each_char.first(4).join
+    self.size = file.each_char.first(4).join.unpack("L<")[0]
+    self.data = ChunkData.new(file, self)
+  
+  end
+  
+  def to_s
+  
+    print "\n\t\"#{self.id}\" <#{self.size}> (\n"
+    print "\t  \"#{self.data.form_type}\",\n"
+    comma_count = self.data.chunks.length - 1
+    self.data.chunks.each do |chunk|
+    
+      #if chunk.id.eql? "fmt "
+        print "\t  < \"#{chunk.id}\" <#{chunk.size}> "
+          chunk.data.chunks.each do |sub_chunk|
+            print "< \"#{sub_chunk.id}\" <#{sub_chunk.size}> >"
+          end
+        #print "\n"
+        case chunk.id
+        when "fmt "
+          print chunk.data.data.to_s
+        when "LIST"
+        end
+        print "\t >"
+        if comma_count > 0
+          print ",\n"
+        else
+          print "\n"
+        end
+        comma_count -= 1
+
+      # else
+      
+        # print "\t  < \"#{chunk.id}\" <#{chunk.size}> "
+          # chunk.data.chunks.each do |sub_chunk|
+            # print "< \"#{sub_chunk.id}\" <#{sub_chunk.size}> >"
+          # end
+        # print " >"
+        # if comma_count > 0
+          # print ",\n"
+        # else
+          # print "\n"
+        # end
+        # comma_count -= 1
+      
+      # end
+    end
+    print "\t)\n"
+  
+  end
+  
+end

data/lib/chunk_data.rb

@@ -0,0 +1,47 @@
+require_relative 'wav_fmt'
+
+class ChunkData < Struct.new(:form_type, :chunks, :parent, :data)
+
+
+  def initialize(file, parent)
+  
+    self.parent = parent
+    self.chunks ||= []
+    
+    case self.parent.id
+    when "RIFF"
+    
+      self.form_type = file.each_char.first(4).join
+      
+      until file.eof?
+        
+        self.chunks << Chunk.new(file)
+        file.pos += self.chunks.last.size
+        
+      end
+    
+    when "fmt "
+      temp_pos = file.pos
+      
+        self.data = WavFmt.new(file.each_char.first(16).join)
+        
+      file.pos = temp_pos
+    else
+    
+      @file_position_of_data = file.pos
+      
+    end
+  
+  end
+  
+  def to_s
+  
+    
+    print "\n  <#{self.form_type}>"
+    self.chunks.each do |chunk|
+        print "\n    <#{chunk.id}> <#{chunk.size}>"
+    end;""
+  
+  end
+
+end

data/lib/four_cc.rb

@@ -0,0 +1,34 @@
+class FourCC < Struct.new(:value)
+
+  # A FOURCC is represented as a sequence of one to four
+  # ASCII alphanumeric characters, padded on the right with
+  # blank characters (ASCII character value 32) as
+  # required, with no embedded blanks (i.e. "H DL" invalid).
+
+  def initialize(value="    ")
+  
+    begin
+      raise "FourCC invalid." unless FourCC.verify(value)
+      self.value = value
+    rescue
+    
+    end
+  
+  end
+  
+  def to_s
+    self.value
+  end
+  
+  private
+  
+  def self.verify(value)
+  
+    valid = true
+    
+    return false unless valid
+    return true
+    
+  end
+  
+end

data/lib/riffy.rb

@@ -0,0 +1,72 @@
+require_relative 'chunk'
+
+class Riffy < Chunk
+
+  attr_reader :type
+  
+  def initialize(file)
+  
+    begin
+      raise "File corrupt or unreadable." unless Riffy.verify(file)
+    rescue
+      
+    end
+      
+    self.id = FourCC.new('RIFF')
+    super(file)
+    
+  end
+  
+  def format #return the format of the RIFF file. e.g. "WAVE"
+  
+    self.data.form_type
+  
+  end
+  
+  def bit_rate
+    self.data.chunks[0].data.data.bit_rate
+  end
+  
+
+  
+  def self.open(file)
+  
+    begin
+      f = File.open(file, "rb")
+    rescue
+      puts "The file failed to load for some reason."
+    end
+    
+    Riffy.new(f)
+    
+  end
+  
+  private
+  
+  def self.parse_riff(file)
+  
+    # parse file by creating chunk objects etc.
+    f = File.open(file)
+    
+    attr_array = []
+    
+    
+    
+    self.id = f.each_char.first(4).join
+    self.size = f.each_char.first(4).join.unpack("L<")[0]
+    
+    puts self.id
+    puts self.size
+    
+    self.data = ChunkData.new(f, :riff)
+    
+    # @type = file[8..11]
+  
+  end
+  
+  def self.verify(file)
+    
+    return true
+  end
+
+end

data/lib/wav_fmt.rb

@@ -0,0 +1,42 @@
+class WavFmt
+
+  attr_reader :bit_rate
+  
+  def initialize(data)
+  
+    # Byte Number 	Size 	Description 	     Value
+    # 0-3 	         4 	  Chunk ID 	         "fmt " (0x666D7420)
+    #@chunk_id = data[0..3]
+    # 4-7 	         4 	  Chunk Data Size 	 Length Of format Chunk (always 0x10)
+    #@chunk_size = data[4..7]
+    # 8-9          	 2 	  Compression code 	 Always 0x01
+    #puts data
+    @compression_code = data[0..1].unpack("C")[0]
+    # 10 - 11 	     2 	  Channel Numbers 	 0x01=Mono, 0x02=Stereo
+    #puts data[2..3].inspect
+    @channels = data[2..3].unpack("C")[0]
+    # 12 - 15 	     4 	  Sample Rate 	     Binary, in Hz
+    @sample_rate = data[4..7].unpack("L")[0]/1000
+    # 16 - 19 	     4 	  Bytes Per Second 	 
+    @kbps = data[8..11].unpack("L")[0]/1000*8
+    @bit_rate = @kbps
+    # 20 - 21 	     2 	  Bytes Per Sample 	 1=8 bit Mono, 2=8 bit Stereo or 16 bit Mono, 4=16 bit Stereo
+    @bytes_per_sample = data[12..13].unpack("C")[0]
+    # 22 - 23 	     2 	  Bits Per Sample 	 
+    @bits_per_sample = data[14..15].unpack("C")[0]
+    
+  end
+
+  def to_s
+  
+    puts "\n\tcompression_code: #{@compression_code}"
+    puts "\t        channels: #{(@channels == 1) ? "Mono" : "Stereo"}"
+    puts "\t     Sample Rate: #{@sample_rate} kHz"
+    puts "\t        Bit Rate: #{@kbps} kbps"
+    puts "\tbytes_per_sample: #{@bytes_per_sample}"
+    print "\t bits_per_sample: #{@bits_per_sample}"
+  
+  end
+
+
+end

metadata

@@ -0,0 +1,51 @@
+--- !ruby/object:Gem::Specification
+name: riffy
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Dominic Muller
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-01-14 00:00:00.000000000 Z
+dependencies: []
+description: Converts RIFF files into Ruby objects
+email: nicklink483@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/riffy.rb
+- lib/chunk.rb
+- lib/chunk_data.rb
+- lib/four_cc.rb
+- lib/wav_fmt.rb
+- bin/test.wav
+homepage: http://rubygems.org/gems/riffy
+licenses:
+- ''
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.28
+signing_key: 
+specification_version: 3
+summary: RIFF file parser
+test_files: []