mmfcc 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c2d12ce70bab6304d063e738501344d110ebb087
+  data.tar.gz: df115cd944bedd7ac3d432a01346bd927909c419
+SHA512:
+  metadata.gz: 209d10bd2cf1a88d339fe787d50ef44581e6243c5309fb767adb6d92806f5941abb3609eb28074c603493a814e41384911632ecae5cfc5603bceb8a69ab0e2e0
+  data.tar.gz: cc5b7b328fe53d3e039d5da16d150ddb59bda499a19ee6dcd0f1db18a3e7c7b2f96ade206811ff64d67cbde3e751852cc954df606acb4045b15354dd5ef5673c

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in mmfcc.gemspec
+gemspec

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/mmfcc

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+require 'pathname'
+lib = Pathname.new(__FILE__).dirname.join('..', 'lib').expand_path
+$LOAD_PATH.unshift lib.to_s
+
+require 'mmfcc/command'
+command = Mmfcc::Command.new
+command.run
+

data/lib/mmfcc.rb

@@ -0,0 +1,2 @@
+require "mmfcc/version"
+

data/lib/mmfcc/clustering.rb

@@ -0,0 +1,85 @@
+
+module Mmfcc
+  require "rubygems"
+  require "ai4r"
+
+  class Clustering
+
+  	def initialize(cnum)
+      @cnum = cnum
+    end
+
+  	def kmeans(all_mfcc, clusterNum)
+
+		ai4r_data = Ai4r::Data::DataSet.new(:data_items=> all_mfcc)
+
+		cluster = Ai4r::Clusterers::KMeans.new
+      	cluster.build(ai4r_data, clusterNum)
+
+      	return cluster
+  	end
+
+  	def loadMFCC(mfccFile, m, all_mfcc)
+	    
+	    mfcc = []
+	    mfccs = []
+
+	    File.open(mfccFile, "r+b")  {|f|
+		  	while line = f.read(4)
+		        if line == "" then
+		        	break
+		        end
+
+		        val = line.unpack('f')[0]
+		        mfcc.push(val)
+		        
+
+		        if mfcc.length==m then
+		        	mfccs.push(mfcc)
+		        	all_mfcc.push(mfcc)
+		        	mfcc=[]
+		        end
+		  	end
+		}
+
+		return mfccs
+    end
+
+    def run
+
+    	mfccDir = './mfcc/'
+
+	    clusterNum = @cnum.to_i
+	    mfcc_dict = {}
+	    all_mfcc = []
+
+	    Find.find(mfccDir) {|mfccFile|
+	    	next unless mfccFile.end_with?(".mfc")
+	    	mfcc = loadMFCC(mfccFile, 20, all_mfcc)
+	    	mfcc_dict[mfccFile]=mfcc
+	    }
+
+	    cluster = kmeans(all_mfcc, clusterNum)
+
+	    writeToFile = File.open("./histgram.txt",'w')
+
+     	mfcc_dict.each{|key, value|
+      		writeToFile.puts key
+
+      		histgram = [0]*clusterNum
+
+      		value.each{|d|
+	      		i = cluster.eval(d)
+	      		histgram[i]+=1
+	      	}
+	      	
+	      	str_hist = histgram.join(" ")
+	      	writeToFile.puts str_hist
+
+      	}
+
+      	puts "histgram.txt is created."
+      	writeToFile.close
+    end
+  end
+end

data/lib/mmfcc/command.rb

@@ -0,0 +1,29 @@
+module Mmfcc
+  require "find"
+
+  class Command
+    def run
+    	require 'optparse'
+
+		params = ARGV.getopts('mc',"type:mp3", "m4apath:./m4a/", "mp3path:./mp3/", "cnum:8")
+
+		if params["m"] then
+			puts "calculating mfcc..."
+
+			require 'mmfcc/mfcc'
+
+			mfcc = Mmfcc::Mfcc.new(params["type"], params["m4apath"], params["mp3path"])
+			mfcc.run
+		end
+
+		if params["c"] then
+			puts "start clustering..."
+
+			require 'mmfcc/clustering'
+
+			clustering = Mmfcc::Clustering.new(params["cnum"])
+			clustering.run
+		end
+    end
+  end
+end

data/lib/mmfcc/mfcc.rb

@@ -0,0 +1,148 @@
+
+module Mmfcc
+  class Mfcc
+
+  	def initialize(type, m4apath, mp3path)
+      @type = type
+      @m4apath = m4apath
+      @mp3path = mp3path
+    end
+
+  	def m4aToRaw(m4aFile)
+	    system("ffmpeg -i "+m4aFile+" -ab 32k -ar 16000 temp.m4a")
+	    # decode mp3 to wav
+	    system("ffmpeg -i temp.m4a temp.wav")
+	    # convert wav to raw
+	    system("sox temp.wav temp.raw")
+	    # delete needless
+	    system("rm temp.m4a")
+	    system("rm temp.wav")
+	end
+
+  	def mp3ToRaw(mp3File)
+	    system("lame --resample 16 -b 32 -a "+mp3File+" temp.mp3")
+	    # decode mp3 to wav
+	    system("lame --decode temp.mp3 temp.wav")
+	    # convert wav to raw
+	    system("sox temp.wav temp.raw")
+	    # delete needless
+	    system("rm temp.mp3")
+	    system("rm temp.wav")
+	end
+
+	def calcNumSample(rawFile)
+	    # calculate byte
+	    filesize = File.size?("temp.raw")
+	    numsample = filesize / 2
+	    return numsample
+	end
+
+	def extractCenter(inFile, outFile, period)
+	    numsample = calcNumSample(inFile)
+	    p numsample
+
+	    fs = 16000
+	    center = numsample / 2
+	    start = center - fs * period
+	    ends = center + fs * period
+
+	    if start < 0 then
+	    	start = 0
+	    end
+	    if ends > numsample - 1 then
+	    	ends = numsample - 1
+	    end
+
+	    system("bcut +s -s "+start.to_s+" -e "+ends.to_s+" < temp.raw > "+outFile)
+	end
+
+	def calcMFCC(rawFile, mfccFile)
+	    # sampling rate: 16kHz
+	    # frame length: 400
+	    # shift broad: 160
+	    # num of channel: 40
+	    # MFCC: 19 dimentions + energy
+	    system("x2x +sf < "+rawFile+" | frame -l 400 -p 160 | mfcc -l 400 -f 16 -n 40 -m 19 -E > "+mfccFile)
+	end
+
+  	def run
+
+      	m4aDir = @m4apath
+      	mp3Dir = @mp3path
+	    mfccDir = './mfcc/'
+    	rawDir = './raw/'
+
+    	if not Dir::exist?(mfccDir) then
+        	Dir::mkdir(mfccDir)
+        end
+    	if not Dir::exist?(rawDir) then
+        	Dir::mkdir(rawDir)
+        end
+
+        if @type == "m4a" then
+
+        	if not Dir::exist?(m4aDir) then
+				raise "there is no directry for m4a. Please make directry ./m4a/"    			
+    		end
+
+	        Find.find(m4aDir) {|m4aFile|
+	        	next unless FileTest.file?(m4aFile)
+				next unless m4aFile.end_with?(".m4a")
+
+	        	mfccFile = m4aFile.sub(".m4a",".mfc")
+			  	mfccFile = mfccFile.sub(m4aDir, mfccDir)
+
+			  	rawFile = m4aFile.sub(".m4a",".raw")
+			  	rawFile = rawFile.sub(m4aDir, rawDir)
+
+			  	begin
+		            # decode MP3
+		            m4aToRaw(m4aFile)
+
+		            # convert 30s mp3 to rawFile
+		            extractCenter("temp.raw", rawFile, 15)
+
+		            calcMFCC(rawFile, mfccFile)
+
+		            system("rm temp.raw")
+		        rescue
+		            next
+		            puts "failed at decode m4a"
+		        end
+	        }
+	    else
+
+	    	if not Dir::exist?(mp3Dir) then
+				raise "there is no directry for mp3. Please make directry ./mp3/"
+    		end
+
+			Find.find(mp3Dir) {|mp3File|
+				next unless FileTest.file?(mp3File)
+			  	next unless mp3File.end_with?(".mp3")
+
+			  	mfccFile = mp3File.sub(".mp3",".mfc")
+			  	mfccFile = mfccFile.sub(mp3Dir, mfccDir)
+
+			  	rawFile = mp3File.sub(".mp3",".raw")
+			  	rawFile = rawFile.sub(mp3Dir, rawDir)
+
+			  	begin
+		            # decode MP3
+		            mp3ToRaw(mp3File)
+
+		            # convert 30s mp3 to rawFile
+		            extractCenter("temp.raw", rawFile, 15)
+
+		            calcMFCC(rawFile, mfccFile)
+
+		            system("rm temp.raw")
+		        rescue
+		            next
+		            puts "failed at decode mp3"
+		        end			
+			}
+
+		end
+  	end
+  end
+end

data/lib/mmfcc/version.rb

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

data/mmfcc.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "mmfcc/version"
+
+Gem::Specification.new do |s|
+  s.name        = "mmfcc"
+  s.version     = Mmfcc::VERSION
+  s.authors     = ["RittaNarita"]
+  s.email       = ["narittan@gmail.com"]
+  s.homepage    = "https://github.com/RittaNarita/Mmfcc"
+  s.summary     = %q{the tool for making mfcc of songs}
+  s.description = %q{you can make the Mel-frequency cepstrum, which is a feature spectrum of a song. }
+  s.license       = "GPLv2"
+  s.rubyforge_project = "mmfcc"
+
+  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"]
+
+  # specify any dependencies here; for example:
+  s.add_development_dependency "ai4r", '~> 0'
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification
+name: mmfcc
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- RittaNarita
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-11-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ai4r
+  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'
+description: 'you can make the Mel-frequency cepstrum, which is a feature spectrum
+  of a song. '
+email:
+- narittan@gmail.com
+executables:
+- mmfcc
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- README.md
+- Rakefile
+- bin/mmfcc
+- lib/mmfcc.rb
+- lib/mmfcc/clustering.rb
+- lib/mmfcc/command.rb
+- lib/mmfcc/mfcc.rb
+- lib/mmfcc/version.rb
+- mmfcc.gemspec
+homepage: https://github.com/RittaNarita/Mmfcc
+licenses:
+- GPLv2
+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: mmfcc
+rubygems_version: 2.2.0
+signing_key: 
+specification_version: 4
+summary: the tool for making mfcc of songs
+test_files: []