hanvox 0.3

data/ext/kissfft/mkmf.log

@@ -0,0 +1,22 @@
+have_library: checking for main() in -lm... -------------------- yes
+
+"gcc -o conftest -I/usr/local/rvm/rubies/ruby-1.9.2-p180/include/ruby-1.9.1/x86_64-darwin10.7.1 -I/usr/local/rvm/rubies/ruby-1.9.2-p180/include/ruby-1.9.1/ruby/backward -I/usr/local/rvm/rubies/ruby-1.9.2-p180/include/ruby-1.9.1 -I. -D_XOPEN_SOURCE -D_DARWIN_C_SOURCE    -O3 -ggdb -Wextra -Wno-unused-parameter -Wno-parentheses -Wpointer-arith -Wwrite-strings -Wno-missing-field-initializers -Wshorten-64-to-32 -Wno-long-long  -fno-common -pipe conftest.c  -L. -L/usr/local/rvm/rubies/ruby-1.9.2-p180/lib -L.      -lruby.1.9.1-static  -lpthread -ldl -lobjc "
+checked program was:
+/* begin */
+1: #include "ruby.h"
+2: 
+3: int main() {return 0;}
+/* end */
+
+"gcc -o conftest -I/usr/local/rvm/rubies/ruby-1.9.2-p180/include/ruby-1.9.1/x86_64-darwin10.7.1 -I/usr/local/rvm/rubies/ruby-1.9.2-p180/include/ruby-1.9.1/ruby/backward -I/usr/local/rvm/rubies/ruby-1.9.2-p180/include/ruby-1.9.1 -I. -D_XOPEN_SOURCE -D_DARWIN_C_SOURCE    -O3 -ggdb -Wextra -Wno-unused-parameter -Wno-parentheses -Wpointer-arith -Wwrite-strings -Wno-missing-field-initializers -Wshorten-64-to-32 -Wno-long-long  -fno-common -pipe conftest.c  -L. -L/usr/local/rvm/rubies/ruby-1.9.2-p180/lib -L.      -lruby.1.9.1-static -lm  -lpthread -ldl -lobjc "
+checked program was:
+/* begin */
+1: #include "ruby.h"
+2: 
+3: /*top*/
+4: int main() {return 0;}
+5: int t() { void ((*volatile p)()); p = (void ((*)()))main; return 0; }
+/* end */
+
+--------------------
+

data/ext/kissfft/test_kissfft.rb

@@ -0,0 +1,47 @@
+#!/usr/bin/ruby
+
+base = File.symlink?(__FILE__) ? File.readlink(__FILE__) : __FILE__
+$:.unshift(File.join(File.dirname(base)))
+
+require 'test/unit'
+require 'kissfft'
+require 'pp'
+
+#
+# Simple unit test
+#
+
+class KissFFT::UnitTest < Test::Unit::TestCase
+	def test_version
+		assert_equal(String, KissFFT.version.class)
+		puts "KissFFT version: #{KissFFT.version}"
+	end		
+	def test_fftr
+		data = File.read('sample.data').unpack('s*')
+		
+		min = 1
+		res = KissFFT.fftr(8192, 8000, 1, data)
+
+		tones = {}
+		res.each do |x|
+			rank = x.sort{|a,b| a[1].to_i <=> b[1].to_i }.reverse
+			rank[0..10].each do |t|
+				f = t[0].round
+				p = t[1].round
+				next if f == 0
+				next if p < min
+				tones[ f ] ||= []
+				tones[ f ] << t
+			end
+		end
+
+		tones.keys.sort.each do |t|
+			next if tones[t].length < 2
+			puts "#{t}hz"
+			tones[t].each do |x|
+				puts "\t#{x[0]}hz @ #{x[1]}"
+			end
+		end
+
+	end					
+end

data/lib/hanvox.rb

@@ -0,0 +1,7 @@
+require "hanvox/proc_audio"
+require "hanvox/raw"
+require "hanvox/version"
+
+module Hanvox
+  
+end

data/lib/hanvox/proc_audio.rb

@@ -0,0 +1,244 @@
+require "kissfft/kissfft"
+require "signatures"
+require "tempfile"
+
+module Hanvox
+  class ProcAudio
+    attr_accessor :channels, :data, :header, :file, :oname, :path, :processors, :results, :sample_count, :save_dir
+    CHUNK_IDS = {:header       => "RIFF",
+                   :format       => "fmt ",
+                   :data         => "data",
+                   :fact         => "fact",
+                   :silence      => "slnt",
+                   :cue          => "cue ",
+                   :playlist     => "plst",
+                   :list         => "list",
+                   :label        => "labl",
+                   :labeled_text => "ltxt",
+                   :note         => "note",
+                   :sample       => "smpl",
+                   :instrument   => "inst" }
+    PACK_CODES = {8 => "C*", 16 => "s*", 32 => "V*"}
+  
+    def initialize path, save_dir=nil
+      @channels, @data, @results = [], [], []
+      @header = {}
+      @save_dir = save_dir || `pwd`.gsub("\n", "")
+      @path = path
+    
+      @file = File.open path
+      @oname = File.basename path, ".wav"
+      read_header
+    end
+  
+    def process opts={}
+      (@header[:channels]).times do |c|
+        c += 1
+        system "sox #{@path} -s #{oname}_#{c}.wav remix #{c}"
+        system "sox #{oname}_#{c}.wav -s #{oname}_#{c}.raw"
+        system "rm -f #{oname}_#{c}.wav"
+        @channels << "#{oname}_#{c}.raw"
+      end
+    
+      if opts[:channel].nil?
+        @channels.each do |chan|
+          process_audio chan
+        end
+      else
+        process_audio @channels[opts[:channel]-1]
+      end
+      cleanup
+    end
+  
+    def process_audio input
+      bname = File.expand_path(File.dirname(input))
+      num   = File.basename(input, ".raw").split("_").last
+      res   = {}
+
+      #
+      # Create the signature database
+      #
+      raw  = Hanvox::Raw.from_file(input)
+      fft  = KissFFT.fftr(8192, 8000, 1, raw.samples)
+
+      freq = raw.to_freq_sig_txt()
+
+      # Save the signature data
+      res[:fprint] = freq
+
+      #
+      # Create a raw decompressed file
+      #
+
+      # Decompress the audio file
+      datfile = Tempfile.new("datfile")
+
+      # Data files for audio processing and signal graph
+      cnt = 0
+      datfile.write(raw.samples.map{|val| cnt +=1; "#{cnt/8000.0} #{val}"}.join("\n"))
+      datfile.flush
+
+      # Data files for spectrum plotting
+      frefile = Tempfile.new("frefile")
+
+      # Calculate the peak frequencies for the sample
+      maxf = 0
+      maxp = 0
+      tones = {}
+      fft.each do |x|
+        rank = x.sort{|a,b| a[1].to_i <=> b[1].to_i }.reverse
+        rank[0..10].each do |t|
+          f = t[0].round
+          p = t[1].round
+          next if f == 0
+          next if p < 1
+          tones[ f ] ||= []
+          tones[ f ] << t
+          if(t[1] > maxp)
+            maxf = t[0]
+            maxp = t[1]
+          end
+        end
+      end
+
+      # Save the peak frequency
+      res[:peak_freq] = maxf
+
+      # Calculate average frequency and peaks over time
+      avg = {}
+      pks = []
+      pkz = []
+      fft.each do |slot|
+        pks << slot.sort{|a,b| a[1] <=> b[1] }.reverse[0]
+        pkz << slot.sort{|a,b| a[1] <=> b[1] }.reverse[0..9]
+        slot.each do |f|
+          avg[ f[0] ] ||= 0
+          avg[ f[0] ] +=  f[1]
+        end
+      end
+
+      # Save the peak frequencies over time
+      res[:peak_freq_data] = pks.map{|f| "#{f[0]}-#{f[1]}" }.join(" ")
+
+      # Generate the frequency file
+      avg.keys.sort.each do |k|
+        avg[k] = avg[k] / fft.length
+        frefile.write("#{k} #{avg[k]}\n")
+      end
+      frefile.flush
+
+      # Count significant frequencies across the sample
+      fcnt = {}
+      0.step(4000, 5) {|f| fcnt[f] = 0 }
+      pkz.each do |fb|
+        fb.each do |f|
+          fdx = ((f[0] / 5.0).round * 5.0).to_i
+          fcnt[fdx]  += 0.1
+        end
+      end
+    
+      @data << { :raw  => raw, :freq => freq, :fcnt => fcnt, :fft  => fft,
+                :pks  => pks, :pkz  => pkz, :maxf => maxf, :maxp => maxp }
+    
+      sigs = Signatures::Base.new @data.last
+      res[:line_type] = sigs.process
+    
+      # Plot samples to a graph
+      plotter = Tempfile.new("gnuplot")
+    
+      plotter.puts("set ylabel \"Signal\"")
+      plotter.puts("set xlabel \"Seconds\"")
+      plotter.puts("set terminal png medium size 640,480 transparent")
+      plotter.puts("set output \"#{save_dir}/#{oname}_#{num}_big.png\"")
+      plotter.puts("plot \"#{datfile.path}\" using 1:2 title \"#{num}\" with lines")
+      plotter.puts("set output \"#{save_dir}/#{oname}_#{num}_big_dots.png\"")
+      plotter.puts("plot \"#{datfile.path}\" using 1:2 title \"#{num}\" with dots")
+    
+      plotter.puts("set terminal png medium size 640,480 transparent")
+      plotter.puts("set ylabel \"Power\"")
+      plotter.puts("set xlabel \"Frequency\"")
+      plotter.puts("set output \"#{save_dir}/#{oname}_#{num}_big_freq.png\"")
+      plotter.puts("plot \"#{frefile.path}\" using 1:2 title \"#{num} - Peak #{maxf.round}hz\" with lines")
+    
+      plotter.puts("set ylabel \"Signal\"")
+      plotter.puts("set xlabel \"Seconds\"")
+      plotter.puts("set terminal png small size 160,120 transparent")
+      plotter.puts("set format x ''")
+      plotter.puts("set format y ''")
+      plotter.puts("set output \"#{save_dir}/#{oname}_#{num}_sig.png\"")
+      plotter.puts("plot \"#{datfile.path}\" using 1:2 notitle with lines")
+    
+      plotter.puts("set ylabel \"Power\"")
+      plotter.puts("set xlabel \"Frequency\"")
+      plotter.puts("set terminal png small size 160,120 transparent")
+      plotter.puts("set format x ''")
+      plotter.puts("set format y ''")
+      plotter.puts("set output \"#{save_dir}/#{oname}_#{num}_sig_freq.png\"")
+      plotter.puts("plot \"#{frefile.path}\" using 1:2 notitle with lines")
+      plotter.flush
+    
+      puts `gnuplot #{plotter.path}&`
+      File.unlink(plotter.path)
+      File.unlink(datfile.path)
+      File.unlink(frefile.path)
+      plotter.close
+      datfile.close
+      frefile.path
+    
+      @results << res
+    end
+  
+    def cleanup
+      @channels.each do |c|
+        system "rm -f #{c}"
+      end
+      @file.close
+    
+      true
+    end
+  
+  private
+    def read_header
+      # Read RIFF header
+      riff_header = @file.sysread(12).unpack("a4Va4")
+      @header[:chunk_id] = riff_header[0]
+      @header[:chunk_size] = riff_header[1]
+      @header[:format] = riff_header[2]
+
+      # Read format subchunk
+      @header[:sub_chunk1_id], @header[:sub_chunk1_size] = read_to_chunk(CHUNK_IDS[:format])
+      format_subchunk_str = @file.sysread(@header[:sub_chunk1_size])
+      format_subchunk = format_subchunk_str.unpack("vvVVvv")  # Any extra parameters are ignored
+      @header[:audio_format] = format_subchunk[0]
+      @header[:channels] = format_subchunk[1]
+      @header[:sample_rate] = format_subchunk[2]
+      @header[:byte_rate] = format_subchunk[3]
+      @header[:block_align] = format_subchunk[4]
+      @header[:bits_per_sample] = format_subchunk[5]
+
+      # Read data subchunk
+      @header[:sub_chunk2_id], @header[:sub_chunk2_size] = read_to_chunk(CHUNK_IDS[:data])
+
+      @sample_count = @header[:sub_chunk2_size] / @header[:block_align]
+    end
+  
+    def read_to_chunk(expected_chunk_id)
+      chunk_id = @file.sysread(4)
+      chunk_size = @file.sysread(4).unpack("V")[0]
+
+      while chunk_id != expected_chunk_id
+        # Skip chunk
+        file.sysread(chunk_size)
+
+        chunk_id = @file.sysread(4)
+        chunk_size = @file.sysread(4).unpack("V")[0]
+      end
+
+      return chunk_id, chunk_size
+    end
+  
+    def format 
+    
+    end
+  end
+end

data/lib/hanvox/raw.rb

@@ -0,0 +1,323 @@
+module Hanvox
+  class Raw
+
+    @@kissfft_loaded = false
+    begin
+      require 'kissfft'
+      @@kissfft_loaded = true
+    rescue ::LoadError
+    end
+
+    require 'zlib'
+
+    ##
+    # RAW AUDIO - 8khz little-endian 16-bit signed
+    ##
+
+    ##
+    # Static methods
+    ##
+
+    def self.from_str(str)
+      self.class.new(str)
+    end
+
+    def self.from_file(path)
+      if(not path)
+        raise Error, "No audio path specified"
+      end
+
+      if(path == "-")
+        return self.new($stdin.read)
+      end
+
+      if(not File.readable?(path))
+        raise Error, "The specified audio file does not exist"
+      end
+
+      if(path =~ /\.gz$/)
+        return self.new(Zlib::GzipReader.open(path).read)
+      end
+
+      self.new(File.read(path, File.size(path)))
+    end
+
+    ##
+    # Class methods
+    ##
+
+    attr_accessor :samples
+
+    def initialize(data)
+      self.samples = data.unpack('v*').map do |s|
+        (s > 0x7fff) ? (0x10000 - s) * -1 : s
+      end
+    end
+  
+    def to_raw
+      self.samples.pack("v*")
+    end
+  
+    def to_wav
+      raw = self.to_raw
+      wav = 
+        "RIFF" + 
+          [raw.length + 36].pack("V") +
+        "WAVE" +
+        "fmt " +
+          [16, 1, 1, 8000, 16000, 2, 16 ].pack("VvvVVvv") +
+        "data" +
+          [ raw.length ].pack("V") +
+        raw
+    end 
+
+    def to_flow(opts={})
+
+      lo_lim = (opts[:lo_lim] || 100).to_i
+      lo_min = (opts[:lo_min] || 5).to_i
+      hi_min = (opts[:hi_min] || 5).to_i
+      lo_cnt = 0
+      hi_cnt = 0
+
+      data = self.samples.map {|c| c.abs}
+
+      #
+      # Granular hi/low state change list
+      #
+      fprint = []
+      state  = :lo
+      idx    = 0
+      buff   = []
+
+      while (idx < data.length)
+        case state
+        when :lo
+          while(idx < data.length and data[idx] <= lo_lim)
+            buff << data[idx]
+            idx += 1
+          end
+
+          # Ignore any sequence that is too small
+          fprint << [:lo, buff.length, buff - [0]] if buff.length > lo_min
+          state  = :hi
+          buff   = []
+          next
+        when :hi
+          while(idx < data.length and data[idx] > lo_lim)
+            buff << data[idx]
+            idx += 1
+          end
+
+          # Ignore any sequence that is too small
+          fprint << [:hi, buff.length, buff] if buff.length > hi_min
+          state  = :lo
+          buff   = []
+          next
+        end
+      end
+
+      #
+      # Merge similar blocks
+      #
+      final = []
+      prev  = fprint[0]
+      idx   = 1
+
+      while(idx < fprint.length)
+
+        if(fprint[idx][0] == prev[0])
+          prev[1] += fprint[idx][1]
+          prev[2] += fprint[idx][2]
+        else
+          final << prev
+          prev  = fprint[idx]
+        end
+
+        idx += 1
+      end
+      final << prev
+
+      #
+      # Process results
+      #
+      sig = ""
+
+      final.each do |f|
+        sum = 0
+        f[2].each {|i| sum += i }
+        avg = (sum == 0) ? 0 : sum / f[2].length
+        sig << "#{f[0].to_s.upcase[0,1]},#{f[1]},#{avg} "
+      end
+
+      # Return the results
+      return sig
+    end
+
+    def to_freq(opts={})
+
+      if(not @@kissfft_loaded)
+        raise RuntimeError, "The KissFFT module is not availabale, raw.to_freq() failed"
+      end
+
+      freq_cnt = opts[:frequency_count] || 20
+
+      # Perform a DFT on the samples
+      ffts = KissFFT.fftr(8192, 8000, 1, self.samples)
+
+      self.class.fft_to_freq_sig(ffts, freq_cnt)
+    end
+
+    def to_freq_sig(opts={})
+      fcnt = opts[:frequency_count] || 5
+
+      ffts = []
+
+      # Obtain 20 DFTs for the sample, at 1/20th second offsets into the stream
+      0.upto(19) do |i|
+        ffts[i] = KissFFT.fftr(8192, 8000, 1, self.samples[ i * 400, self.samples.length - (i * 400)])
+      end
+
+      # Create a frequency table at 100hz boundaries
+      f = [ *(0.step(4000, 100)) ]
+
+      # Create a worker method to find the closest frequency
+      barker = Proc.new do |t|
+        t = t.to_i
+        f.sort { |a,b|
+          (a-t).abs <=> (b-t).abs
+        }.first
+      end
+
+      # Map each slice of the audio's FFT with each FFT chunk (8k samples) and then work on it
+      tops = ffts.map{|x| x.map{|y| y.map{|z|
+
+        frq,pwr = z
+
+        # Toss any signals with a strength under 100
+        if pwr < 100.0
+          frq,pwr = [0,0]
+        # Map the signal to the closest offset of 100hz
+        else
+          frq = barker.call(frq)
+        end
+
+        # Make sure the strength is an integer
+        pwr = pwr.to_i
+
+        # Sort by signal strength and take the top fcnt items
+        [frq, pwr]}.sort{|a,b|
+          b[1] <=> a[1]
+        }[0, fcnt].map{|w|
+        # Grab just the frequency (drop the strength)
+          w[0]
+        # Remove any duplicates due to hz mapping
+        }.uniq
+
+      } }
+
+      # Track the generated 4-second chunk signatures
+      sigs = []
+
+      # Expand the list of top frequencies per sample into a flat list of each permutation
+      tops.each do |t|
+        next if t.length < 4
+        0.upto(t.length - 4) { |i| t[i].each { |a| t[i+1].each { |b| t[i+2].each { |c| t[i+3].each { |d| sigs << [a,b,c,d] } } } } }
+      end
+
+      # Dump any duplicate signatures
+      sigs = sigs.uniq
+
+      # Convert each signature into a single 32-bit integer
+      # This is essentially [0-40, 0-40, 0-40, 0-40]
+      sigs.map{|x| x.map{|y| y / 100}.pack("C4").unpack("N")[0] }
+    end
+
+    # Converts a signature to a postgresql integer array (text) format
+    def to_freq_sig_txt(opts={})
+      "{" + to_freq_sig(opts).sort.join(",") + "}"
+    end
+
+    def self.fft_to_freq_sig(ffts, freq_cnt)
+      sig = []
+      ffts.each do |s|
+        res = []
+        maxp = 0
+        maxf = 0
+        s.each do |f|
+          if( f[1] > maxp )
+            maxf,maxp = f
+          end
+
+          if(maxf > 0 and f[1] < maxp and (maxf + 4.5 < f[0]))
+            res << [maxf, maxp]
+            maxf,maxp = [0,0]
+          end
+        end
+
+        sig << res.sort{ |a,b|                             # sort by signal strength
+          a[1] <=> b[1]
+        }.reverse[0,freq_cnt].sort { |a,b|                 # take the top 20 and sort by frequency
+          a[0] <=> b[0]
+        }.map {|a| [a[0].round, a[1].round ] }             # round to whole numbers
+      end
+
+      sig
+    end
+
+    # Find pattern inside of sample
+    def self.compare_freq_sig(pat, zam, opts)
+
+      fuzz_f = opts[:fuzz_f] || 7
+      fuzz_p = opts[:fuzz_p] || 10
+      final  = []
+
+      0.upto(zam.length - 1) do |si|
+        res = []
+        sam = zam[si, zam.length]
+
+        0.upto(pat.length - 1) do |pi|
+          diff = []
+          next if not pat[pi]
+          next if pat[pi].length == 0
+          pat[pi].each do |x|
+            next if not sam[pi]
+            next if sam[pi].length == 0
+            sam[pi].each do |y|
+              if(
+                (x[0] - fuzz_f) < y[0] and
+                (x[0] + fuzz_f) > y[0] and
+                (x[1] - fuzz_p) < y[1] and
+                (x[1] + fuzz_p) > y[1]
+              )
+                diff << x
+                break
+              end
+            end
+          end
+          res << diff
+        end
+        next if res.length == 0
+
+        prev = 0
+        rsum = 0
+        ridx = 0
+        res.each_index do |xi|
+          len = res[xi].length
+          if(xi == 0)
+            rsum += (len < 2) ? -40 : +20
+          else
+            rsum += 20 if(prev > 11 and len > 11)
+            rsum += len
+          end
+          prev = len
+        end
+
+        final << [ (rsum / res.length.to_f), res.map {|x| x.length}]
+      end
+
+      final
+    end
+
+
+  end
+end