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"])