audio-fingerprint 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7676a6ff2be66e896893e5c3eb10646c7f5298ed
+  data.tar.gz: 48b9e6d77ae290b6ec8c7bfef0f203eec29cb36f
+SHA512:
+  metadata.gz: 5099311c77a1a6b43b20c6a5e02383cd2cfd47e934f2f5060ffbc0c1243b02d9863064670245a75946dfbca2471db975422f4860e3e628083516970c36dad496
+  data.tar.gz: 3faf8c32f9db80c063cc482b1cee21198503e026f91f224beb8f8548e0e1e77ed3ce7c443b6973a6c0a1031354ca87b71061a77882ba26e746ac6b9614f583a5

data/Rakefile

@@ -0,0 +1,9 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+end
+
+desc "Run tests"
+task :default => :test

data/audio-fingerprint.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'audio_fingerprint/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "audio-fingerprint"
+  spec.version       = AudioFingerprint::VERSION
+  spec.authors       = ["Rafael Fragoso"]
+  spec.email         = ["rafaelfragosom@gmail.com"]
+  spec.summary       = %q{Small gem to fingerprint .wav audio files and compare them}
+  spec.description   = %q{This gem can fingerprint from small to large pieces of wav audio and run a math to compare them (this is very handy to compare audio notes)}
+  spec.homepage      = "https://github.com/rafaelfragosom/audio-fingerprint"
+  spec.license       = "MIT"
+
+  spec.files         = Dir["{lib,bin,test}/**/*", "Rakefile", "README.rdoc", "*.gemspec"]
+  spec.executables   = %w(audio_fingerprint)
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake", '~> 0'
+  spec.add_dependency "fftw3", '~> 0'
+end

data/bin/audio_fingerprint

@@ -0,0 +1,15 @@
+#!/this/will/be/replaced/by/rubygems
+# -*- encoding: binary -*-
+
+require 'audio_fingerprint/version'
+require 'audio_fingerprint/fingerprint'
+
+if ARGV[0].nil?
+	STDERR.puts "Version: #{AudioFingerprint::VERSION}"
+	STDERR.puts "Usage: <input file|url>"
+	exit(1)
+else
+	f = AudioFingerprint::Fingerprint.new(ARGV[0])
+	f.create_fingerprint
+	STDERR.puts f.fingerprint.inspect
+end

data/lib/audio_fingerprint.rb

@@ -0,0 +1,7 @@
+require 'audio_fingerprint/version'
+require 'audio_fingerprint/fingerprint'
+require 'audio_fingerprint/wave_file'
+require 'fftw3'
+
+module AudioFingerprint
+end

data/lib/audio_fingerprint/fingerprint.rb

@@ -0,0 +1,74 @@
+require 'audio_fingerprint/wave_file'
+require 'fftw3'
+
+class Float
+	def to_near
+		(self+0.5).to_i
+	end
+end
+
+module AudioFingerprint
+	class Fingerprint
+
+		BITS_PER_RAW_ITEM = 32
+		THRESHOLD = 0.85
+
+		attr_accessor :fingerprint
+		attr_accessor :file
+
+		def initialize(file)
+			@fingerprint = []
+			@file = file
+		end
+
+		def create_fingerprint
+			w    		 = AudioFingerprint::WaveFile.open(@file)
+			samples  	 = w.sample_data[0, [w.sample_rate * 10, w.sample_data.size].min]
+			duration 	 = samples.size / w.sample_rate
+			na 			 = NArray.float(2, samples.size)
+			@fingerprint ||= []
+			
+			samples.each_with_index do |v, i|
+				na[0, i - 1] = i.to_f / w.sample_rate.to_f
+				na[1, i - 1] = v
+			end
+
+			fa = FFTW3.fft(na)
+			fa = fa.real.abs
+
+			fa.each do |f|
+				@fingerprint << f
+			end
+		end
+
+		def compare(fp)
+			max_raw_size = [@fingerprint.size, fp.size].max
+			bit_size     = max_raw_size * BITS_PER_RAW_ITEM
+
+			distance     = hamming_distance(@fingerprint, fp)
+
+			match 		 = 1 - distance.to_f / bit_size
+
+			if match >= THRESHOLD
+				match
+			else
+				false
+			end
+		end
+
+		private
+
+		def hamming_distance(raw1, raw2)
+			distance = 0
+
+			min_size, max_size = [raw1, raw2].map(&:size).sort
+
+			min_size.times do |i|
+				distance += (raw1[i].to_near ^ raw2[i].to_near).to_s(2).count('1')
+			end
+
+			distance += (max_size - min_size) * BITS_PER_RAW_ITEM
+		end
+
+	end
+end

data/lib/audio_fingerprint/version.rb

@@ -0,0 +1,3 @@
+module AudioFingerprint
+	VERSION = "0.0.1"
+end

data/lib/audio_fingerprint/wave_file.rb

@@ -0,0 +1,416 @@
+###############################################################################
+### This class was took from the wavefile gem version 0.3.0 to fit my needs ###
+### https://github.com/jstrait/wavefile #######################################
+###############################################################################
+
+module AudioFingerprint
+    class WaveFile
+        CHUNK_ID = "RIFF"
+        FORMAT = "WAVE"
+        FORMAT_CHUNK_ID = "fmt "
+        SUB_CHUNK1_SIZE = 16
+        PCM = 1
+        DATA_CHUNK_ID = "data"
+        HEADER_SIZE = 36
+
+        def initialize(num_channels, sample_rate, bits_per_sample, sample_data = [])
+            if num_channels == :mono
+                @num_channels = 1
+            elsif num_channels == :stereo
+                @num_channels = 2
+            else
+                @num_channels = num_channels
+            end
+            @sample_rate = sample_rate
+            @bits_per_sample = bits_per_sample
+            @sample_data = sample_data
+
+            @byte_rate = sample_rate * @num_channels * (bits_per_sample / 8)
+            @block_align = @num_channels * (bits_per_sample / 8)
+        end
+      
+        def self.open(path)
+            file = File.open(path, "rb")
+
+            begin
+                header = read_header(file)
+                errors = validate_header(header)
+
+                if errors == []
+                    sample_data = read_sample_data(file,
+                    header[:num_channels],
+                    header[:bits_per_sample],
+                    header[:sub_chunk2_size])
+
+                    wave_file = self.new(header[:num_channels],
+                    header[:sample_rate],
+                    header[:bits_per_sample],
+                    sample_data)
+                else
+                    error_msg = "#{path} can't be opened, due to the following errors:\n"
+                    errors.each {|error| error_msg += "  * #{error}\n" }
+                    raise StandardError, error_msg
+                end
+            rescue EOFError
+                raise StandardError, "An error occured while reading #{path}."
+            ensure
+                file.close()
+            end
+
+            return wave_file
+        end
+
+        def save(path)
+            # All numeric values should be saved in little-endian format
+
+            sample_data_size = @sample_data.length * @num_channels * (@bits_per_sample / 8)
+
+            # Write the header
+            file_contents = CHUNK_ID
+            file_contents += [HEADER_SIZE + sample_data_size].pack("V")
+            file_contents += FORMAT
+            file_contents += FORMAT_CHUNK_ID
+            file_contents += [SUB_CHUNK1_SIZE].pack("V")
+            file_contents += [PCM].pack("v")
+            file_contents += [@num_channels].pack("v")
+            file_contents += [@sample_rate].pack("V")
+            file_contents += [@byte_rate].pack("V")
+            file_contents += [@block_align].pack("v")
+            file_contents += [@bits_per_sample].pack("v")
+            file_contents += DATA_CHUNK_ID
+            file_contents += [sample_data_size].pack("V")
+
+            # Write the sample data
+            if !mono?
+                output_sample_data = []
+                @sample_data.each{|sample|
+                    sample.each{|sub_sample|
+                        output_sample_data << sub_sample
+                    }
+                }
+            else
+                output_sample_data = @sample_data
+            end
+
+            if @bits_per_sample == 8
+                file_contents += output_sample_data.pack("C*")
+            elsif @bits_per_sample == 16
+                file_contents += output_sample_data.pack("s*")
+            else
+                raise StandardError, "Bits per sample is #{@bits_per_samples}, only 8 or 16 are supported"
+            end
+
+            file = File.open(path, "w")
+            file.syswrite(file_contents)
+            file.close
+        end
+
+        def sample_data()
+            return @sample_data
+        end
+
+        def normalized_sample_data()    
+            if @bits_per_sample == 8
+                min_value = 128.0
+                max_value = 127.0
+                midpoint = 128
+            elsif @bits_per_sample == 16
+                min_value = 32768.0
+                max_value = 32767.0
+                midpoint = 0
+            else
+                raise StandardError, "Bits per sample is #{@bits_per_samples}, only 8 or 16 are supported"
+            end
+
+            if mono?
+                normalized_sample_data = @sample_data.map {|sample|
+                    sample -= midpoint
+                    if sample < 0
+                        sample.to_f / min_value
+                    else
+                        sample.to_f / max_value
+                    end
+                }
+            else
+                normalized_sample_data = @sample_data.map {|sample|
+                    sample.map {|sub_sample|
+                        sub_sample -= midpoint
+                        if sub_sample < 0
+                            sub_sample.to_f / min_value
+                        else
+                            sub_sample.to_f / max_value
+                        end
+                    }
+                }
+            end
+
+            return normalized_sample_data
+        end
+      
+        def sample_data=(sample_data)
+            if sample_data.length > 0 && ((mono? && sample_data[0].class == Float) ||
+                                        (!mono? && sample_data[0][0].class == Float))
+            if @bits_per_sample == 8
+                # Samples in 8-bit wave files are stored as a unsigned byte
+                # Effective values are 0 to 255, midpoint at 128
+                min_value = 128.0
+                max_value = 127.0
+                midpoint = 128
+            elsif @bits_per_sample == 16
+                # Samples in 16-bit wave files are stored as a signed little-endian short
+                # Effective values are -32768 to 32767, midpoint at 0
+                min_value = 32768.0
+                max_value = 32767.0
+                midpoint = 0
+            else
+                raise StandardError, "Bits per sample is #{@bits_per_samples}, only 8 or 16 are supported"
+            end
+
+            if mono?
+                @sample_data = sample_data.map {|sample|
+                    if(sample < 0.0)
+                    (sample * min_value).round + midpoint
+                    else
+                    (sample * max_value).round + midpoint
+                    end
+                }
+            else
+                @sample_data = sample_data.map {|sample|
+                    sample.map {|sub_sample|
+                        if(sub_sample < 0.0)
+                            (sub_sample * min_value).round + midpoint
+                        else
+                            (sub_sample * max_value).round + midpoint
+                        end
+                    }
+                }
+            end
+            else
+                @sample_data = sample_data
+            end
+        end
+
+        def mono?()
+            return num_channels == 1
+        end
+
+        def stereo?()
+            return num_channels == 2
+        end
+
+        def reverse()
+            sample_data.reverse!()
+        end
+
+        def duration()
+            total_samples = sample_data.length
+            samples_per_millisecond = @sample_rate / 1000.0
+            samples_per_second = @sample_rate
+            samples_per_minute = samples_per_second * 60
+            samples_per_hour = samples_per_minute * 60
+            hours, minutes, seconds, milliseconds = 0, 0, 0, 0
+
+            if(total_samples >= samples_per_hour)
+                hours = total_samples / samples_per_hour
+                total_samples -= samples_per_hour * hours
+            end
+
+            if(total_samples >= samples_per_minute)
+                minutes = total_samples / samples_per_minute
+                total_samples -= samples_per_minute * minutes
+            end
+
+            if(total_samples >= samples_per_second)
+                seconds = total_samples / samples_per_second
+                total_samples -= samples_per_second * seconds
+            end
+
+            milliseconds = (total_samples / samples_per_millisecond).floor
+
+            return  { :hours => hours, :minutes => minutes, :seconds => seconds, :milliseconds => milliseconds }
+        end
+
+        def bits_per_sample=(new_bits_per_sample)
+            if new_bits_per_sample != 8 && new_bits_per_sample != 16
+                raise StandardError, "Bits per sample of #{@bits_per_samples} is invalid, only 8 or 16 are supported"
+            end
+
+            if @bits_per_sample == 16 && new_bits_per_sample == 8
+                conversion_func = lambda {|sample|
+                    if(sample < 0)
+                        (sample / 256) + 128
+                    else
+                        # Faster to just divide by integer 258?
+                        (sample / 258.007874015748031).round + 128
+                    end
+                }
+
+                if mono?
+                    @sample_data.map! &conversion_func
+                else
+                    sample_data.map! {|sample| sample.map! &conversion_func }
+                end
+                elsif @bits_per_sample == 8 && new_bits_per_sample == 16
+                    conversion_func = lambda {|sample|
+                        sample -= 128
+                        if(sample < 0)
+                            sample * 256
+                        else
+                            # Faster to just multiply by integer 258?
+                            (sample * 258.007874015748031).round
+                        end
+                    }
+
+                if mono?
+                    @sample_data.map! &conversion_func
+                else
+                    sample_data.map! {|sample| sample.map! &conversion_func }
+                end
+            end
+
+            @bits_per_sample = new_bits_per_sample
+        end
+      
+        def num_channels=(new_num_channels)
+            if new_num_channels == :mono
+                new_num_channels = 1
+            elsif new_num_channels == :stereo
+                new_num_channels = 2
+            end
+
+            # The cases of mono -> stereo and vice-versa are handled in specially,
+            # because those conversion methods are faster than the general methods,
+            # and the large majority of wave files are expected to be either mono or stereo.    
+            if @num_channels == 1 && new_num_channels == 2
+                sample_data.map! {|sample| [sample, sample]}
+            elsif @num_channels == 2 && new_num_channels == 1
+                sample_data.map! {|sample| (sample[0] + sample[1]) / 2}
+            elsif @num_channels == 1 && new_num_channels >= 2
+                sample_data.map! {|sample| [].fill(sample, 0, new_num_channels)}
+            elsif @num_channels >= 2 && new_num_channels == 1
+                sample_data.map! {|sample| sample.inject(0) {|sub_sample, sum| sum + sub_sample } / @num_channels }
+            elsif @num_channels > 2 && new_num_channels == 2
+                sample_data.map! {|sample| [sample[0], sample[1]]}
+            end
+
+            @num_channels = new_num_channels
+        end
+
+        def inspect()
+            duration = self.duration()
+
+            result =  "Channels:        #{@num_channels}\n" +
+                        "Sample rate:     #{@sample_rate}\n" +
+                        "Bits per sample: #{@bits_per_sample}\n" +
+                        "Block align:     #{@block_align}\n" +
+                        "Byte rate:       #{@byte_rate}\n" +
+                        "Sample count:    #{@sample_data.length}\n" +
+                        "Duration:        #{duration[:hours]}h:#{duration[:minutes]}m:#{duration[:seconds]}s:#{duration[:milliseconds]}ms\n"
+        end
+
+        attr_reader :num_channels, :bits_per_sample, :byte_rate, :block_align
+        attr_accessor :sample_rate
+      
+    private
+
+        def self.read_header(file)
+            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] = self.read_to_chunk(file, FORMAT_CHUNK_ID)
+            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[:num_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] = self.read_to_chunk(file, DATA_CHUNK_ID)
+
+            return header
+        end
+
+        def self.read_to_chunk(file, 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 self.validate_header(header)
+            errors = []
+
+            unless header[:bits_per_sample] == 8  ||  header[:bits_per_sample] == 16
+                errors << "Invalid bits per sample of #{header[:bits_per_sample]}. Only 8 and 16 are supported."
+            end
+
+            unless (1..65535) === header[:num_channels]
+                errors << "Invalid number of channels. Must be between 1 and 65535."
+            end
+
+            unless header[:chunk_id] == CHUNK_ID
+                errors << "Unsupported chunk ID: '#{header[:chunk_id]}'"
+            end
+
+            unless header[:format] == FORMAT
+                errors << "Unsupported format: '#{header[:format]}'"
+            end
+
+            unless header[:sub_chunk1_id] == FORMAT_CHUNK_ID
+                errors << "Unsupported chunk id: '#{header[:sub_chunk1_id]}'"
+            end
+
+            unless header[:audio_format] == PCM
+                errors << "Unsupported audio format code: '#{header[:audio_format]}'"
+            end
+
+            unless header[:sub_chunk2_id] == DATA_CHUNK_ID
+                errors << "Unsupported chunk id: '#{header[:sub_chunk2_id]}'"
+            end
+
+            return errors
+        end
+      
+        # Assumes that file is "queued up" to the first sample
+        def self.read_sample_data(file, num_channels, bits_per_sample, sample_data_size)
+            if(bits_per_sample == 8)
+                data = file.sysread(sample_data_size).unpack("C*")
+            elsif(bits_per_sample == 16)
+                data = file.sysread(sample_data_size).unpack("s*")
+            else
+                data = []
+            end
+
+            if(num_channels > 1)
+                multichannel_data = []
+
+                i = 0
+                while i < data.length
+                    multichannel_data << data[i...(num_channels + i)]
+                    i += num_channels
+                end
+
+                data = multichannel_data
+            end
+
+            return data
+        end
+    end
+end

data/test/test_fingerprint.rb

@@ -0,0 +1,44 @@
+require 'test/unit'
+require 'audio_fingerprint/fingerprint'
+
+class TestFingerprint < Test::Unit::TestCase
+
+	FILE_PATH1 = '/Users/Rafael/Desktop/previsao.wav'
+	FILE_PATH2 = '/Users/Rafael/Desktop/bomdia.wav'
+
+	def test_get_fingerprint
+		# Create the instance
+		f = AudioFingerprint::Fingerprint.new(FILE_PATH1)
+		# Generate Fingerprint
+		f.create_fingerprint
+		# Fingerprint should be generated in a huge array
+		assert_kind_of(Array, f.fingerprint, "The audio fingerprinted was not correct.")
+	end
+
+	def test_compare_true
+		# Create the instance
+		f1 = AudioFingerprint::Fingerprint.new(FILE_PATH1)
+		f2 = AudioFingerprint::Fingerprint.new(FILE_PATH1)
+		# Generate Fingerprint
+		f1.create_fingerprint
+		f2.create_fingerprint
+
+		compare  = f1.compare(f2.fingerprint)
+
+		assert_kind_of(Float, compare, "The compare math didn't worked for equal signature.")
+	end
+
+	def test_compare_false
+		# Create the instance
+		f1 = AudioFingerprint::Fingerprint.new(FILE_PATH1)
+		f2 = AudioFingerprint::Fingerprint.new(FILE_PATH2)
+		# Generate Fingerprint
+		f1.create_fingerprint
+		f2.create_fingerprint
+
+		compare  = f1.compare(f2.fingerprint)
+
+		assert(!compare, "The compare math didn't worked for a different signature.")
+	end
+
+end

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification
+name: audio-fingerprint
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Rafael Fragoso
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-02-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: fftw3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0'
+description: This gem can fingerprint from small to large pieces of wav audio and
+  run a math to compare them (this is very handy to compare audio notes)
+email:
+- rafaelfragosom@gmail.com
+executables:
+- audio_fingerprint
+extensions: []
+extra_rdoc_files: []
+files:
+- Rakefile
+- audio-fingerprint.gemspec
+- bin/audio_fingerprint
+- lib/audio_fingerprint.rb
+- lib/audio_fingerprint/fingerprint.rb
+- lib/audio_fingerprint/version.rb
+- lib/audio_fingerprint/wave_file.rb
+- test/test_fingerprint.rb
+homepage: https://github.com/rafaelfragosom/audio-fingerprint
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Small gem to fingerprint .wav audio files and compare them
+test_files:
+- test/test_fingerprint.rb