def recognizeAudio():
djv = Dejavu(config)
djv.fingerprint_directory("songs", [".mp3"], 3)
print "starting recognition"
song = djv.recognize(MicrophoneRecognizer, seconds=5)
print "finished recognition"
print(song)
return song['song_name']
class DejavuPlainDBTestCases(unittest.TestCase):
def setUp(self):
self.djv = Dejavu(config_plain)
def tearDown(self):
self.djv.db.empty()
del self.djv
def test_fingerprint_1_file(self):
self.djv.fingerprint_file("tests/test1.mp3")
# should be the only fingerprinted file
self.assertEqual(1, self.djv.db.get_num_songs())
self.assertEqual(5279, self.djv.db.get_num_fingerprints())
def test_fingerprint_directory(self):
list_dir = [f for f in os.listdir("tests") if f[-4:] == ".mp3"]
self.djv.fingerprint_directory("tests", [".mp3"])
self.assertEqual(len(list_dir), self.djv.db.get_num_songs())
def test_fingerprint_1_file_10secs(self):
self.djv.limit = 10
self.djv.fingerprint_file("tests/test1.mp3")
# should be the only fingerprinted file
self.assertEqual(1, self.djv.db.get_num_songs())
# fingerprinting the first 10 secs of this test file,
# shouldn't get more than 3000 hashes.
self.assertEqual(2554, self.djv.db.get_num_fingerprints())
def test_recognize_1_file(self):
self.djv.fingerprint_file("tests/test1.mp3")
self.djv.fingerprint_file("tests/test2.mp3")
song = self.djv.recognize(FileRecognizer, "tests/test2.mp3")
self.assertEqual(song["song_name"], "tests/test2.mp3")
def fingerprintAndComputeAccuracy(fingerprintReduction, peakSort,
defaultOverlapRatio, defaultFanValue,
defaultAmpMin, peakNeighbourhoodSize):
# create a Dejavu instance
djv = Dejavu(config)
# Fingerprint all the mp3's in the directory we give it
djv.fingerprint_directory("mp3", [".mp3"])
def run_client():
"""
runs all the patches
"""
run()
directory_path = raw_input("enter the directory path")
djv = Dejavu(config)
djv.fingerprint_directory(directory_path, [".mp3"], 3)
def main():
config = {
"database": {
"host": "127.0.0.1",
"user": "******",
"passwd": "root",
"db": "Philadelphia"
}
}
djv = Dejavu(config)
# start fingerprint
djv.fingerprint_directory("../../Seattle/data/songs", [".mp3"], 4)
print djv.db.get_num_fingerprints()
def __main1():
# create a Dejavu instance
djv = Dejavu(config)
# Fingerprint all the mp3's in the directory we give it
djv.fingerprint_directory("seed", [".wav"])
#print djv.db.get_num_fingerprints()
#print "----------------------------17---------"
fp = open('result'+'.dat','w+')
# Recognize audio from a file
prefix ='mp3'
start = time.clock()
totalNumSong = 0
rightNum = 0
missNum = 0
# for root, dirs, files in os.walk(prefix):
# for dirx in dirs:
# fp.write('%s\n'%dirx)
print "-------------------------------------"
fp.write("--Recognizing-----------------------------------\n")
for filename in glob.glob(prefix+'/*.wav'):
#print filename
# filenamex= os.path.basename(filename).replace('.wav','')
song = djv.recognize(FileRecognizer, filename)
totalNumSong += 1
if not song is None:
txtBuffer = "%s; %s"%(filename, filter(str.isalpha, song['song_name']))
if filename[5:7] in filter(str.isalpha, song['song_name']):
rightNum += 1
else:
txtBuffer = "%s; None"%(filename)
missNum +=1
fp.write(txtBuffer+'\n')
print txtBuffer
end=time.clock()
fp.write("--Performance-----------------------------------\n")
fp.write("Prediction time duration: %f seconds\n"%(end-start))
fp.write("Total number of predicted songs: %d \n"%totalNumSong)
fp.write("Prediction duration per song: %f seconds\n"%(float(end-start)/float(totalNumSong)))
fp.write("Correct rate: %f %% \n"%(float(rightNum)/float(totalNumSong)*100))
fp.write("No result rate: %f %%\n"%(float(missNum)/float(totalNumSong)*100))
fp.close()
def scan_directory(directory, extension):
if extension.endswith('.mp3'):
print('scanning directory...'.format(directory))
djv = Dejavu(config)
djv.fingerprint_directory(directory, [extension], 3) # 3 is processes
elif extension.endswith('.m4a'):
print('scanning directory...'.format(directory))
djv = Dejavu(config)
djv.fingerprint_directory(directory, [extension], 3) # 3 is processes
else:
print("file format '{0}' not coded yet".format(extension))
# recognise mp3
song = djv.recognize(FileRecognizer, "/home/jonas/Downloads/dejavu/CC.mp3")
print("found song '%s\n'" % song)
def fingerprint():
uploaded_files = request.files.getlist("files")
for file in uploaded_files:
filename = secure_filename(file.filename)
file.save(os.path.join("song", filename))
print "Mean aii"
with open("dejavu.cnf.SAMPLE") as f:
config = json.load(f)
djv = Dejavu(config)
djv.fingerprint_directory("song", [".mp3"])
for file in uploaded_files:
filename = secure_filename(file.filename)
path = "song/" + filename
os.remove(path)
print "Delete aii"
return render_template('index.html', code=1)
def instructor_input(request):
user_id = request.META['HTTP_USERID']
class_id = request.META['HTTP_CLASSID']
session = request.META['HTTP_SESSIONNAME']
version = request.META['HTTP_VERSIONNAME']
djv = Dejavu(config)
filename = 'media/instructor/instructor_' + user_id +'_' + class_id + '_' + session +'_' + version +'.wav'
uploadedFile = open(filename, "wb")
uploadedFile.write(request.body)
uploadedFile.close()
c = Classroom.objects.get(id=1) # hardcoded
u = User.objects.get(id=1)
InstructorInbound(user = u, classroom = c, session = session, time_in=datetime.now().replace(tzinfo=None)).save()
djv.fingerprint_directory("media/instructor/", [".wav"])
response = djv.db.get_num_fingerprints()
digest.run()
return HttpResponse(response)
def song_rater(rec_audio):
"""
Receive recorded audio and returns song name and confidence level
"""
# Create a Dejavu instance
djv = Dejavu(config)
# Create the directory if not found
if not os.path.exists(BASE_DIR + "/rater/mp3"):
os.makedirs(BASE_DIR + "/rater/mp3")
file_dir = BASE_DIR + "/rater/mp3"
# Fingerprint all the mp3's in the directory given which is mp3
djv.fingerprint_directory(file_dir, [".mp4"])
song = djv.recognize(FileRecognizer, rec_audio)
print("From file we recognized: %s\n" % song)
return song['song_name'], song['confidence']
def recognize(self, samples_patch, downloads_patch, file_format):
self.samples_patch = samples_patch
self.downloads_patch = downloads_patch
self.file_format = file_format
self.var_check()
warnings.filterwarnings('ignore')
with open('dejavu.conf') as f:
config = json.load(f)
djv = Dejavu(config)
# -= updating audio fingerprint base =-
print ('%s > Updating fingerprints...' % datetime.datetime.now())
djv.fingerprint_directory(self.samples_patch, [self.file_format])
# -= recognizing downloaded files =-
print ('%s > Recognizing files...' % datetime.datetime.now())
for i in range(len(names)):
file = self.downloads_patch + '/' + names[i]
print ('%s > Now recognizing: %s' % (datetime.datetime.now(), names[i]))
song = djv.recognize(FileRecognizer, file)
recognized.append(song['song_name'])
print ('%s > From file we recognized: %s' % (datetime.datetime.now(), recognized[i]))
print ('%s > Finished!' % datetime.datetime.now())
def __main(action):
# create a Dejavu instance
djv = Dejavu(config)
# Fingerprint all the mp3's in the directory we give it
djv.fingerprint_directory("mp3", [".wav"])
#print djv.db.get_num_fingerprints()
#print "----------------------------17---------"
fp = open(action+'.dat','w+')
# Recognize audio from a file
#prefix ='..\sdl\%s'%action
prefix ='mp3\%s'%action
files = prefix +'\*.mp3'
totalNumSong = 0
start = time.clock()
for filename in glob.glob(files):
#print filename
filenamex= filename.split('\\')[-1]
filenamex=filenamex[7:-4]
song = djv.recognize(FileRecognizer, filename)
totalNumSong += 1
if not song is None:
txtBuffer = "%s;%s"%(filenamex, song['song_name'])
else:
txtBuffer = "%s;None"%(filenamex)
fp.write(txtBuffer+'\n')
print txtBuffer
end=time.clock()
fp.write("----------------------------60---------\n")
fp.write("Prediction time duration: %f \n"%(end-start))
fp.write("Total number of predicted songs: %d \n"%totalNumSong)
fp.write("Prediction duration for per song: %f \n"%(float(end-start)/float(totalNumSong)))
fp.close()
def receive(self, data):
text_data_json = json.loads(data)
session = text_data_json['SESSIONNAME']
class_id = text_data_json['CLASSID']
version = text_data_json['VERSIONNAME']
user_id = text_data_json['USERID']
audio = text_data_json['audio']
djv = Dejavu(config)
filename = 'media/instructor/instructor_' + user_id +'_' + class_id + '_' + session +'_' + version +'.wav'
uploadedFile = open(filename, "wb")
uploadedFile.write(audio)
uploadedFile.close()
c = Classroom.objects.get(id=1) # hardcoded
u = User.objects.get(id=1)
InstructorInbound(user = u, classroom = c, session = session, time_in=datetime.now()).save()
djv.fingerprint_directory("media/instructor/", [".wav"])
response = djv.db.get_num_fingerprints()
self.send(text_data=json.dumps({
'message': "received",
'fingerprints': response
}))
config_settings = ConfigParser.ConfigParser()
config_settings.read("configuration.config")
config = {
"database": {
"host": config_settings.get("configuration", "aws_db_host"),
"user": config_settings.get("configuration", "aws_db_user"),
"passwd": config_settings.get("configuration", "aws_db_pwd"),
"db": config_settings.get("configuration", "aws_db_name"),
},
"database_type": "mysql",
"fingerprint_limit": 10
}
djv = Dejavu(config)
djv.fingerprint_directory("audio_merged", [".mp3", ".wav"])
#result = djv.recognize(FileRecognizer, "train_audio/door_bell_1.mp3")
def record_and_match(djv_copy):
match = 0
result = djv_copy.recognize(MicrophoneRecognizer, seconds=WINDOW_SIZE)
print(result)
if result is not None:
if result['confidence'] > 3:
print("This is matched" + result["song_name"])
match = 1
elif result["offset_seconds"] > 0.5 and result["offset"] > 10:
print("This is matched" + result["song_name"])
match = 1
import warnings
import json
import os
import time
warnings.filterwarnings("ignore")
from dejavu import Dejavu
from dejavu.recognize import FileRecognizer, MicrophoneRecognizer
# load config from a JSON file (or anything outputting a python dictionary)
with open("dejavu.cnf") as f:
config = json.load(f)
if __name__ == '__main__':
# create a Dejavu instance
config["database"]["passwd"] = os.environ.get(config["database"]["passwd"])
config["database"]["db"] = os.environ.get(config["database"]["db"])
djv = ""
for i in range(0, 20):
try:
djv = Dejavu(config)
break
except Exception,e:
print e
time.sleep(1)
# Fingerprint all the mp3's in the directory we give it
djv.fingerprint_directory("scripts", [".wav"])
# kugou_krc_song = KugouKrcSong.get(KugouKrcSong.o2o_id == o2o_id)
# _download_link = kugou_krc_song.download_link
# url = kcloud + _download_link
# req = urllib2.Request(url)
# res = urllib2.urlopen(req)
# res = res.read()
# res = json.loads(res)
# download_link = res.get('result')
# print download_link
# download_link = download_link.replace(internal_url, out_url)
# print download_link
# urllib.urlretrieve(download_link,'/data/dejavu/'+str(o2o_id)+'$'+o2o_name+'.mp3')
print 100 * '*'
djv.fingerprint_directory("/data/dejavu", [".mp3"])
print 100 * '*'
dejavu_song = djv.recognize(FileRecognizer, "t_music/地球好危险啊(HD).ts")
o2o_id = dejavu_song.get('song_name').split('$')[0]
confidence = dejavu_song.get('confidence')
print dejavu_song.get('song_name')
print o2o_id
print confidence
# q = FingerPrints.delete()
# q.execute()
# q = DejavuSongs.delete()
# q.execute()
filelist = []
__author__ = 'Mark'
from dejavu import Dejavu
if __name__ == '__main__':
config = {
"database": {
"host": "127.0.0.1",
"user": "******",
"passwd": "root",
"db": "dejavu"
}
}
djv = Dejavu(config)
djv.fingerprint_directory("../../../Desktop/media/dejavu",[".wav",".mp3",".mov",".MOV"])
print djv.db.get_num_fingerprints()
warnings.filterwarnings("ignore")
from dejavu import Dejavu
from dejavu.recognize import FileRecognizer, MicrophoneRecognizer
# load config from a JSON file (or anything outputting a python dictionary)
with open("dejavu.cnf.SAMPLE") as f:
config = json.load(f)
if __name__ == '__main__':
# create a Dejavu instance
djv = Dejavu(config)
# Fingerprint all the mp3's in the directory we give it
djv.fingerprint_directory("mp3/irish-music", [".mp3"])
# Recognize audio from a file
song = djv.recognize(FileRecognizer, "mp3/Sean-Fournier--Falling-For-You.mp3")
print "From file we recognized: %s\n" % song
# Recognize audio from a file with white noise overlayed on top of it
song = djv.recognize(FileRecognizer, "overlays/overlayed-track.mp3")
print "From file we recognized: %s\n" % song
# Or recognize audio from your microphone for `secs` seconds
secs = 5
song = djv.recognize(MicrophoneRecognizer, seconds=secs)
if song is None:
print "Nothing recognized -- did you play the song out loud so your mic could hear it? :)"
warnings.filterwarnings("ignore")
from dejavu import Dejavu
from dejavu.recognize import FileRecognizer, MicrophoneRecognizer
# load config from a JSON file (or anything outputting a python dictionary)
with open("dejavu.cnf.SAMPLE") as f:
config = json.load(f)
if __name__ == '__main__':
# create a Dejavu instance
djv = Dejavu(config)
# Fingerprint all the mp3's in the directory we give it
djv.fingerprint_directory("isolated_test_mp3", [".mp3"])
files = 0
correctMatches = 0
# Recognize all files from test suite
# loop through length of folder and check for correct match and compute percentage retained
for snippet in os.listdir('test_suite_overlays'):
files = files + 1
matchedSong = djv.recognize(FileRecognizer,
'test_suite_overlays/' + snippet)
try:
songMatched = matchedSong['song_name']
if (songMatched == snippet.split('__')[0]):
print('CORRECT')
correctMatches = correctMatches + 1
else:
# create a Dejavu instance
djv = Dejavu(config)
os.mkdir(dir_name)
# Fingerprint all the mp3's in the directory we give it
songs_tag = []
starting_time = time.time()
print("start time: ", starting_time)
for num, song in enumerate(songs_arr, 1):
client.download_file(Bucket='songs-1',
Key=song['Key'],
Filename=song['Key'])
songs_tag.append(song['Key'])
if ((num) == len(songs_arr)) or (((num) % num_vcpu) == 0):
start = time.time()
djv.fingerprint_directory(dir_name, [".mp3"])
print("batch:", songs_tag, time.time()-start)
if num > last_run_at:
with open('log.csv', 'a') as writeFile:
writer = csv.writer(writeFile)
writer.writerows([[num/4, songs_tag, time.time()-start]])
songs_tag = []
shutil.rmtree(dir_name)
os.mkdir(dir_name)
final_end_time = time.time()
print("end time: ", final_end_time)
with open('total_time.csv', 'a') as writeFile:
writer = csv.writer(writeFile)
writer.writerows([["complete time", final_end_time-starting_time]])
# load config from a JSON file (or anything outputting a python dictionary)
from dejavu import Dejavu
#from dejavu.logic.recognizer.microphone_recognizer import MicrophoneRecognizer
from dejavu.recognize import MicrophoneRecognizer
config = {
"database": {
"host": "127.0.0.1",
"user": "******",
"password": "******",
"database": "dejavu",
}
}
djv = Dejavu(config)
djv.fingerprint_directory("/home/mayank/Music/dejavu-master/mp3", [".mp3"])
print djv.db.get_num_fingerprints()
print "listning audio from newpy"
song = djv.recognize(MicrophoneRecognizer, seconds=10)
import sys
import os
import MySQLdb
import MySQLdb.cursors
from dejavu import Dejavu
warnings.filterwarnings("ignore")
db = os.path.abspath("python/database.json")
config = {}
try:
with open(db) as f:
config['database'] = json.load(f)
con = MySQLdb.connect(
config.get('database').get('host'),
config.get('database').get('user'),
config.get('database').get('passwd'),
config.get('database').get('db'),
cursorclass=MySQLdb.cursors.DictCursor
)
cur = con.cursor()
cur.execute("SELECT * FROM `configurations` ORDER BY id DESC")
config['fingerprint'] = cur.fetchone()
if __name__ == '__main__':
djv = Dejavu(config)
djv.fingerprint_directory()
except MySQLdb.Error, e:
print "Error %d: %s" % (e.args[0], e.args[1])
sys.exit(1)
def main(threadname):
global status
print (threadname)
info = {
'FORMAT' : pyaudio.paInt16,
'CHANNELS' : 1,
'RATE' : 48000,
'CHUNK' : 8192,
'RECORD_SECONDS' : 5,
'WAVE_OUTPUT_FILENAME' : "recording.wav",
'THRESHOLD' : 1000
}
frames = []
FORMAT = info['FORMAT']
CHANNELS = info['CHANNELS']
RATE = info['RATE']
CHUNK = info['CHUNK']
RECORD_SECONDS = info['RECORD_SECONDS']
WAVE_OUTPUT_FILENAME = info['WAVE_OUTPUT_FILENAME']
THRESHOLD = info['THRESHOLD']
audio = pyaudio.PyAudio()
confidence_threshold = 5
config = {
"database": {
"host": "127.0.0.1",
"user": "******",
"passwd": "rasp",
"db": "sound_db",
}
}
# create a Dejavu instance
djv = Dejavu(config)
# Fingerprint all the mp3's in the directory we give it
djv.fingerprint_directory("sounds", [".wav"])
# Prints total number of fingerprints - for debugging
print djv.db.get_num_fingerprints()
record = False
while True:
stream = audio.open(format=FORMAT, channels=CHANNELS,
rate=RATE, input=True,
frames_per_buffer=CHUNK,
input_device_index=4)
print "listening..."
while True:
# while status=='STOP':
# time.sleep(1.5)
data = stream.read(CHUNK)
print 'streaming'
level = audioop.rms(data, 2)
#print "%s" % level
if level > THRESHOLD or record:
frames = []
print "recording"
for i in range(0, int(RATE / CHUNK * RECORD_SECONDS)):
data = stream.read(CHUNK)
frames.append(data)
if status=='START':
# name = get from server
add_new_sound(audio, frames, info, filename)
urllib2.urlopen("http://ec2-54-71-180-108.us-west-2.compute.amazonaws.com/hearboi/device/record/stop")
files = {'audioFile': open(filename, 'rb')}
uploadSite = 'http://ec2-54-71-180-108.us-west-2.compute.amazonaws.com/hearboi/device/record/upload'
r = requests.post(uploadSite, files=files)
else:
add_new_sound(audio, frames, info, info['WAVE_OUTPUT_FILENAME'])
print "finished recording"
song = djv.recognize(FileRecognizer, "recording.wav")
try:
song_name = song['song_name']
song_conf = song['confidence']
print 'song return:', song
except:
song_name = None
song_conf = 0
if song_conf > confidence_threshold:
print "From file we recognized: %s\n" % song
print "Alerting with SMS"
website = 'http://ec2-54-71-180-108.us-west-2.compute.amazonaws.com/hearboi/device/sendSMS/4'
urllib2.urlopen(website).read()
stream.stop_stream()
stream.close()
audio.terminate()
break
class Generate(object):
"""
Given a labelled output file and the corresponding video tags, extracts the commercial segments and fingerprints them.
"""
def __init__(self, labels_fname, video_name):
label_file_type = mimetypes.guess_type(labels_fname)[0]
video_file_type = mimetypes.guess_type(video_name)[0]
if label_file_type[:3] != "tex":
#The file is not a labels file
print "Incorrect label file"
raise Exception(INCORRECT_LABEL_FILE_ERROR)
if video_file_type[:3] != "vid":
#The file is not a video file
print "Incorrect video file"
raise Exception(INCORRECT_VIDEO_FILE_ERROR)
self.labels = LabelsFile(labels_fname)
self.video_name = video_name
self.djv = Dejavu(CONFIG)
self.db_content = []
def build_db(self, aud_ext=".wav", vid_ext=".mpg"):
"""
Build a sql db with the commercials
"""
#This returns the entire contents of the file, more about structure of return type in fileHandler.py
labels = self.labels.read_lables()
#Number of files in the directory + 1
filename = len(os.listdir(DB_AUDIO)) + 1
#Try reading contents from csv file, if it already exists
try:
#Already exists
#We open and read the content first
with open(DBNAME) as f:
lines = f.readlines()
self.db_content = [line.split(',')[1] for line in lines[1:]] #Only names of commercials
f = open(DBNAME, "a")
except:
#Creating for the first time
print "File does not exist so creating..."
f = open(DBNAME, "w")
f.write("name, duration, path\n")
for data in labels:
#Extracting based on structure of return type
start = data[0]
end = data[1]
name = data[2]
if self.db_content != [] and (name in self.db_content):
print "Already Fingerprinted"
continue
duration = timeFunc.get_delta_string(start, end)
#Create a file in the db folder, audio and video are stored seperately
ffmpeg.create_video(start, duration, self.video_name, DB_VIDEO + str(filename) + vid_ext)
ffmpeg.create_audio(DB_VIDEO + str(filename) + vid_ext, DB_AUDIO + str(filename) + aud_ext)
#Create a corresponding entry in the csv file
s = ",".join([name, duration])
s = s + "," + DB_VIDEO + str(filename) + vid_ext + "\n" #Check verified to be true since human tagged
f.write(s)
filename += 1
def fingerprint_db(self, aud_ext=".wav", no_proc=1):
#This fingerprints the entire directory
self.djv.fingerprint_directory(DB_AUDIO, [aud_ext])
def clean_db(self, aud_ext=".wav", vid_ext=".mpg"):
choice = raw_input("Are you sure you want to remove all commercials in the database? (yes/no)")
if choice == "yes":
#Clear the mysql db
self.djv.clear_data()
print "Cleaning database.."
#Now we remove files from db/audio and db/video
filename = len(os.listdir(DB_AUDIO)) + 1
for i in range(1, filename):
try:
os.remove(DB_AUDIO + str(i) + aud_ext)
os.remove(DB_VIDEO + str(i) + vid_ext)
except:
print "File already removed, or you don't have permission"
os.remove(DBNAME)
print "Database is empty"
def run(self, aud_ext=".wav", vid_ext=".mpg"):
self.build_db(aud_ext, vid_ext)
self.fingerprint_db(aud_ext, vid_ext)
"passwd": "pass",
"db": "dejavu"
}
}
# load config from a JSON file (or anything outputting a python dictionary)
#with open("dejavu.cnf.SAMPLE") as f:
# config = json.load(f)
if __name__ == '__main__':
# create a Dejavu instance
djv = Dejavu(config)
# Fingerprint all the mp3's in the directory we give it
djv.fingerprint_directory("mp3", [".mp3"])
# Recognize audio from a file
song = djv.recognize(FileRecognizer, "mp3/Sean-Fournier--Falling-For-You.mp3")
print "From file we recognized: %s\n" % song
# Or recognize audio from your microphone for `secs` seconds
secs = 5
song = djv.recognize(MicrophoneRecognizer, seconds=secs)
if song is None:
print "Nothing recognized -- did you play the song out loud so your mic could hear it? :)"
else:
print "From mic with %d seconds we recognized: %s\n" % (secs, song)
# Or use a recognizer without the shortcut, in anyway you would like
recognizer = FileRecognizer(djv)
#After setting up, dejavu locally on my machine
#Credits and Reference: https://github.com/worldveil/dejavu
import warnings
import json
import subprocess
import moviepy.editor as mp
warnings.filterwarnings("ignore")
from dejavu import Dejavu
from dejavu.recognize import FileRecognizer, MicrophoneRecognizer
# load config from a JSON file (or anything outputting a python dictionary)
with open("dejavu.cnf.SAMPLE") as f:
config = json.load(f)
conf_scores = []
if __name__ == '__main__':
djv = Dejavu(config) # create a Dejavu instance
djv.fingerprint_directory("mp3", [".mp3"]) # Fingerprints all the mp3's in the directory given
for i in range(0,300,6): #checks for audio in first 5 minutes with 5-6 second audio taken at a time
clip = mp.VideoFileClip("your/video/clip").subclip(i,i+5) #extract the subclip
clip.audio.write_audiofile("output/audio/file")
song = djv.recognize(FileRecognizer, "output/audio/file") #to recognize the extracted audio file
print "Recognized: %s\n" % song['song_name'], song['confidence'] #name of recognized song with confidence
conf_scores.append(song['confidence'])
print (conf_scores)
if not args.fingerprint and not args.recognize:
parser.print_help()
sys.exit(0)
djv = Dejavu(dburl=args.dburl, fingerprint_limit=args.limit)
if args.fingerprint:
# Fingerprint all files in a directory
if len(args.fingerprint) == 2:
directory = args.fingerprint[0]
extension = args.fingerprint[1]
print(
"Fingerprinting all .%s files in the %s directory" %
(extension, directory)
)
djv.fingerprint_directory(directory, ["." + extension], 4)
elif len(args.fingerprint) == 1:
filepath = args.fingerprint[0]
if os.path.isdir(filepath):
print(
"Please specify an extension if you'd like to fingerprint a directory!"
)
sys.exit(1)
djv.fingerprint_file(filepath)
elif args.recognize:
# Recognize audio source
song = None
source = args.recognize[0]
opt_arg = args.recognize[1]
from dejavu import Dejavu
from dejavu.recognize import MicrophoneRecognizer
config = {
"database": {
"host": "127.0.0.1",
"user": "******",
"passwd": '',
"db": 'songpop',
}
}
djv = Dejavu(config)
djv.fingerprint_directory("mp3", [".mp3"])
song = djv.recognize(MicrophoneRecognizer, seconds=10)
print(song)
waveFile.setframerate(RATE)
waveFile.writeframes(b''.join(frames))
waveFile.close()
config = {
"database": {
"host": "127.0.0.1",
"user": "******",
"passwd": "rasp",
"db": "sound_db",
}
}
# create a Dejavu instance
djv = Dejavu(config)
# Fingerprint all the mp3's in the directory we give it
djv.fingerprint_directory("sounds", [".wav"])
# Prints total number of fingerprints - for debugging
#print djv.db.get_num_fingerprints()
# Recognize audio from a file
song = djv.recognize(FileRecognizer, "recording.wav")
print "From file we recognized: %s\n" % song
if song:
print "Alerting with SMS"
website = 'http://ec2-54-71-180-108.us-west-2.compute.amazonaws.com/hearboi/device/sendSMS/4'
urllib2.urlopen(website).read()
def fingerprint_op(files_root,extensions):
djv = Dejavu(config)
djv.fingerprint_directory(files_root, extensions,nprocesses=1)
from dejavu import Dejavu
# Database connection config.
config = {
"database": {
"host": "localhost",
"user": "******",
"passwd": "dejavu",
"db": "dejavu",
},
"database_type": "mysql",
}
# Creates a new instance.
djv = Dejavu(config)
# Collects all songs.
djv.fingerprint_directory("data/audios/", [".mp3"])
print("We have collected %s fingerprints." % djv.db.get_num_fingerprints())
account_sid = "AC51365a670d38f32fb1bc163bf0f300fc"
auth_token = "8cf63b9fd2d05385cabfb175b94dab1b"
client = TwilioRestClient(account_sid, auth_token)
def sendsms(msg, phonenum):
message = client.messages.create(body=msg,
to="+1" + phonenum,
from_="+13472189059")
print(message.sid)
while True:
djv.fingerprint_directory("../files", [".wav"], 3)
# print djv.db.get_num_fingerprints()
# try:
# song = djv.recognize(FileRecognizer, "../test/file.3gp")
# print song
# # print song
# if song != None:
# print "found"
# sendsms('someone is at the door', '3474595013')
# # os.remove("../test/file.3gp")
# except:
# pass
try:
song = djv.recognize(FileRecognizer, "../test/file.3gp")
import warnings
import json
warnings.filterwarnings("ignore")
from dejavu import Dejavu
from dejavu.recognize import FileRecognizer
# load config from a JSON file (or anything outputting a python dictionary)
with open("dejavu.cnf.SAMPLE") as f:
config = json.load(f)
if __name__ == '__main__':
# create a Dejavu instance
djv = Dejavu(config)
# Fingerprint all the mp3's in the directory we give it
djv.fingerprint_directory("media/instructor", [".wav"])
# Recognize audio from a file
#song = djv.recognize(FileRecognizer, "media/student/student.wav")
#print ("From file we recognized: %s\n" % song)
# -*- coding: utf-8 -*-
import sys
reload(sys)
sys.setdefaultencoding('utf8')
from dejavu import Dejavu
config = {
"database": {
"host": "127.0.0.1", #"192.168.1.171",
"user": "******",
"passwd": "1234567",
"db": "ir_data",
}
}
djv = Dejavu(config)
djv.fingerprint_directory("MusicTrain", [".wav"], 4)
print (djv.db.get_num_fingerprints())
from dejavu import Dejavu
config = {
"database": {
"host": "127.0.0.1",
"user": "******",
"passwd": "thimmareddy@1",
"db": "dejavu"
}
}
djv = Dejavu(config)
djv.fingerprint_directory(r"C:\Users\Hemanth\dejavu\mp3", [".mp3"], 3)
add_noise,
[
(0.25, ), # signal-to-noise ratio
(1, ),
(4, ),
(16, )
]),
'shift': (
shift,
[
(sample_rate, -20), # (sample_rate, shift)
(sample_rate, 20),
(sample_rate, -40),
(sample_rate, 40),
(sample_rate, -100),
(sample_rate, 100)
])
}
# augment data
aug_filenames = {}
for aug_func_name, (aug_func, param_sets) in aug_funcs.items():
aug_filenames[aug_func_name] = augment(DATA_DIR, f'{filename}.wav',
aug_func_name, aug_func,
param_sets)
# fingerprint
with suppress_stdout_stderr():
djv.fingerprint_directory(DATA_DIR, ['wav'])
from dejavu import Dejavu
config = {
"database": {
"host": "127.0.0.1",
"user": "******",
"db": "dejavu",
},
"database_type": "mysql",
}
djv = Dejavu(config)
djv.fingerprint_directory("./sounds", [".mp3"], 3)
print djv.db.get_num_fingerprints()
import sys, os, shutil
sys.path.insert(1, "../dejavu/")
from dejavu import Dejavu
def copy_all_wavs_to_dir(olddir="./songs", newdir="./fp_wavs"):
for yt_id in filter(lambda x: x[0] != ".", os.listdir(olddir)):
fp = os.path.join(olddir, yt_id, "song.wav")
new_fp = os.path.join(newdir, yt_id + ".wav")
print fp, new_fp
shutil.copy(fp, new_fp)
if "copy" in sys.argv:
copy_all_wavs_to_dir()
if "train" in sys.argv:
config = {"database": {"host": "127.0.0.1", "user": "******", "passwd": "loganlogan", "db": "dejavu"}}
djv = Dejavu(config)
djv.fingerprint_directory("./fp_wavs", [".wav"], 5)
import sys
sys.path.insert(0, './dejavu')
from dejavu import Dejavu
import warnings
import json
warnings.filterwarnings("ignore")
# load config from a JSON file (or anything outputting a python dictionary)
with open("dejavu.cnf") as f:
config = json.load(f)
# create a Dejavu instance
djv = Dejavu(config)
# Fingerprint all the mp3's in the directory we give it
djv.fingerprint_directory("assets", [".mp3"])
# Recognize audio from a file
#from dejavu.recognize import FileRecognizer
#song = djv.recognize(FileRecognizer, "mp3/beware.mp3")
# Or recognize audio from your microphone for 10 seconds
#from dejavu.recognize import MicrophoneRecognizer
#song = djv.recognize(MicrophoneRecognizer, seconds=2)
# Or use a recognizer without the shortcut, in anyway you would like
#from dejavu.recognize import FileRecognizer
#recognizer = FileRecognizer(djv)
#song = recognizer.recognize_file("mp3/sail.mp3")
warnings.filterwarnings("ignore")
from dejavu import Dejavu
from dejavu.recognize import FileRecognizer, MicrophoneRecognizer
# load config from a JSON file (or anything outputting a python dictionary)
with open("dejavu.cnf.SAMPLE") as f:
config = json.load(f)
if __name__ == '__main__':
# create a Dejavu instance
djv = Dejavu(config)
# Fingerprint all the mp3's in the directory we give it
djv.fingerprint_directory("songs", [".mp3"])
# Recognize audio from a file
song = djv.recognize(FileRecognizer, "songs/Dangerously.mp3")
print "From file we recognized: %s\n" % song
#
# # Or recognize audio from your microphone for `secs` seconds
# secs = 5
# song = djv.recognize(MicrophoneRecognizer, seconds=secs)
# if song is None:
# print "Nothing recognized -- did you play the song out loud so your mic could hear it? :)"
# else:
# print "From mic with %d seconds we recognized: %s\n" % (secs, song)
#
# # Or use a recognizer without the shortcut, in anyway you would like
from dejavu import Dejavu
from dejavu.logic.recognizer.file_recognizer import FileRecognizer
from dejavu.logic.recognizer.microphone_recognizer import MicrophoneRecognizer
# load config from a JSON file (or anything outputting a python dictionary)
with open("dejavu.cnf.SAMPLE") as f:
config = person.load(f)
if __name__ == '__main__':
# create a Dejavu instance
djv = Dejavu(config)
# Fingerprint all the mp3's in the directory we give it
djv.fingerprint_directory("test", [".wav"])
# Recognize audio from a file
results = djv.recognize(FileRecognizer, "mp3/Josh-Woodward--I-Want-To-Destroy-Something-Beautiful.mp3")
print(f"From file we recognized: {results}\n")
# Or recognize audio from your microphone for `secs` seconds
secs = 5
results = djv.recognize(MicrophoneRecognizer, seconds=secs)
if results is None:
print("Nothing recognized -- did you play the audio out loud so your mic could hear it? :)")
else:
print(f"From mic with {secs} seconds we recognized: {results}\n")
# Or use a recognizer without the shortcut, in anyway you would like
recognizer = FileRecognizer(djv)
# database uris examples:
# mysql: 'mysql+mysqldb://scott:tiger@localhost/foo'
# postgresql: 'postgresql://*****:*****@localhost/mydatabase'
# sqlite: 'sqlite:///foo.db'
# in memory sqlite: 'sqlite://'
config = {
"database_backend" : "orm",
"database_uri": "sqlite:///fingerprints.sqlite",
"fingerprint_limit" : 10,
}
# previous backend can still be used:
# config = {
# "database_backend" : "plain",
# "database": {
# "host": "127.0.0.1",
# "user": "",
# "passwd": "",
# "db": "",
# },
# "fingerprint_limit": 10,
# }
# create a Dejavu instance
djv = Dejavu(config)
# Fingerprint a file
djv.fingerprint_directory("tests", [".mp3"])
