def make_recording(self):
self.status.configure(text='Recording...')
self.root.update_idletasks()
self.audio, self.sr = record()
self.status.configure(text='Ready to identify.')
createGraph()
self.plotGraph()
self.root.update_idletasks()
def callback(data, frame_count, time_info, status):
# GLOBALS
global WIDTH
global CHANNELS
global RATE
global CHUNK
global STATE
global NEXT_STATE
# DATA
global counter
global alternate_counter
global freq
global period
global prev_sound
global min_sound
global max_sound
global noise_rms
global noise_amp
global noise_dly
global spk_rms
global spk_mult
global spk_dly
out = bytes([])
#######################################
# STATE STARTED #
#######################################
if (STATE == state.STARTED):
de = signal.decode(data, WIDTH, CHANNELS, CHUNK)
min_sound = avg.running_avg(avg.rms(de[0]))
out = signal.encode_signal(WIDTH, CHUNK, [[1, 0], [
1, 0
]]) #Apparently setting all values to 0 turns the sound stream off...
if (counter > 50):
STATE = state.PLAY_NOISE
counter = 0
signal.encode_init(CHANNELS, period)
out = signal.encode_signal(WIDTH, CHUNK, [[noise_amp, 0], [0, 0]])
#######################################
# STATE PLAY NOISE #
#######################################
elif (STATE == state.PLAY_NOISE):
out = signal.encode_signal(WIDTH, CHUNK, [[noise_amp, 0], [0, 0]])
if (counter > 50):
STATE = state.RECORD_NOISE
counter = 0
avg.running_avg_init(25)
recording.recording_init()
print(STATE)
#######################################
# STATE RECORD NOISE #
#######################################
elif (STATE == state.RECORD_NOISE):
de = signal.decode(data, WIDTH, CHANNELS, CHUNK)
recording.record(de)
noise_rms = avg.running_avg(avg.rms(de[1]))
out = signal.encode_signal(WIDTH, CHUNK, [[noise_amp, 0], [0, 0]])
if (counter > 50):
print("noise RMS:%f" % noise_rms)
recording.play_init()
STATE = state.RECORD_NOISE_DONE
counter = 0
#######################################
# STATE RECORD NOISE DONE #
#######################################
elif (STATE == state.RECORD_NOISE_DONE):
de = recording.get_next()
de[1] = [int(i * spk_mult) for i in de[0]]
de[0] = [0 for k in range(0, CHUNK)]
out = signal.encode_data(de, WIDTH, CHANNELS, CHUNK)
if (counter > 10):
STATE = state.MATCH_PLAYBACK
avg.running_avg_init(5)
counter = 0
#######################################
# STATE MATCH PLAYBACK #
#######################################
elif (STATE == state.MATCH_PLAYBACK):
re = recording.get_next()
re[1] = [int(i * spk_mult) for i in re[0]]
re[0] = [0 for k in range(0, CHUNK)]
out = signal.encode_data(re, WIDTH, CHANNELS, CHUNK)
de = signal.decode(data, WIDTH, CHANNELS, CHUNK)
spk_rms = avg.running_avg(avg.rms(de[1]))
if (counter > 10):
counter = 0
avg.running_avg_init(5)
if (avg.close_enough(spk_rms, noise_rms, 100)):
STATE = state.MATCH_PLAYBACK_DONE
# NOT SURE IF GOOD
elif (spk_rms > noise_rms):
spk_mult = spk_mult - (spk_rms - noise_rms) / 100000
elif (spk_rms < noise_rms):
spk_mult = spk_mult + (noise_rms - spk_rms) / 100000
#######################################
# STATE MATCH PLAYBACK DONE #
#######################################
elif (STATE == state.MATCH_PLAYBACK_DONE):
print("AMPLITUDE MATCHED!")
alternate_counter = 0
counter = 0
avg.running_avg_init(5)
signal.get_sine_init(period)
max_sound = spk_rms + noise_rms
recording.queue_init(CHUNK)
de = signal.decode(data, WIDTH, CHANNELS, CHUNK)
recording.queue_record(de)
re = recording.queue_get_signal(CHUNK, 0, 0)
de[1] = [i * spk_mult for i in re]
de[0] = signal.get_sine(noise_amp, CHUNK)
out = signal.encode_data(de, WIDTH, CHANNELS, CHUNK)
STATE = state.MEASURE_BOTH_INIT
#######################################
# STATE MEASURE BOTH INIT #
#######################################
elif (STATE == state.MEASURE_BOTH_INIT):
dly = 18
print(min_sound, prev_sound, spk_dly)
spk_dly += dly
de = signal.decode(data, WIDTH, CHANNELS, CHUNK)
prev_sound = avg.running_avg(avg.rms(de[1]))
recording.queue_record(de)
re = recording.queue_get_signal(CHUNK, 0, dly)
de[1] = [i * spk_mult for i in re]
de[0] = signal.get_sine(noise_amp, CHUNK)
out = signal.encode_data(de, WIDTH, CHANNELS, CHUNK)
avg.running_avg_init(5)
print("Begin tweaking phase!")
STATE = state.DELAY_SPEAKER
counter = 0
#######################################
# STATE DELAY SPEAKER #
#######################################
elif (STATE == state.DELAY_SPEAKER):
NEXT_STATE = state.DELAY_SPEAKER
# dly = int((prev_sound - min_sound)/(max_sound-min_sound)*RATE/signal.SIGNAL_SAMPLE_SIZE)+1
dly = 1
print(min_sound, prev_sound, spk_dly)
spk_dly += dly
de = signal.decode(data, WIDTH, CHANNELS, CHUNK)
recording.queue_record(de)
re = recording.queue_get_signal(CHUNK, 0, dly)
de[1] = [i * spk_mult for i in re]
de[0] = signal.get_sine(noise_amp, CHUNK)
out = signal.encode_data(de, WIDTH, CHANNELS, CHUNK)
STATE = state.MEASURE_BOTH
#######################################
# STATE EXPEDITE SPEAKER #
#######################################
elif (STATE == state.EXPEDITE_SPEAKER):
NEXT_STATE = state.EXPEDITE_SPEAKER
# dly = int((prev_sound - min_sound)/(max_sound-min_sound)*RATE/signal.SIGNAL_SAMPLE_SIZE)+1
dly = 1
print(min_sound, prev_sound, spk_dly)
spk_dly -= dly
de = signal.decode(data, WIDTH, CHANNELS, CHUNK)
recording.queue_record(de)
re = recording.queue_get_signal(CHUNK, 0, -dly)
de[1] = [i * spk_mult for i in re]
de[0] = signal.get_sine(noise_amp, CHUNK)
out = signal.encode_data(de, WIDTH, CHANNELS, CHUNK)
STATE = state.MEASURE_BOTH
#######################################
# STATE MEASURE BOTH #
#######################################
elif (STATE == state.MEASURE_BOTH):
de = signal.decode(data, WIDTH, CHANNELS, CHUNK)
cur_sound = avg.running_avg(avg.rms(de[1]))
recording.queue_record(de)
re = recording.queue_get_signal(CHUNK, 0, 0)
de[1] = [i * spk_mult for i in re]
de[0] = signal.get_sine(noise_amp, CHUNK)
out = signal.encode_data(de, WIDTH, CHANNELS, CHUNK)
if counter > 10:
if (cur_sound <= min_sound or alternate_counter > 10): # LOL FIX!!
STATE = state.DONE
# Actual delay: queue_size * CHUNK - sample_pt
print(
"freq: %d, noise_amp: %d, noise_dly: %d, spk_mult: %f spk_dly: %d"
% (freq, noise_amp, noise_dly, spk_mult, spk_dly))
elif (cur_sound < prev_sound):
STATE = NEXT_STATE
else:
alternate_counter += 1
if (NEXT_STATE == state.EXPEDITE_SPEAKER):
STATE = state.DELAY_SPEAKER
else:
STATE = state.EXPEDITE_SPEAKER
print(STATE)
prev_sound = cur_sound
avg.running_avg_init(5)
counter = 0
#######################################
# STATE DONE #
#######################################
elif (STATE == state.DONE):
de = signal.decode(data, WIDTH, CHANNELS, CHUNK)
cur_sound = avg.running_avg(avg.rms(de[1]))
recording.queue_record(de)
re = recording.queue_get_signal(CHUNK, 0, 0)
de[1] = [i * spk_mult for i in re]
de[0] = signal.get_sine(noise_amp, CHUNK)
out = signal.encode_data(de, WIDTH, CHANNELS, CHUNK)
if (counter > 100):
print(min_sound, cur_sound)
counter = 0
counter += 1
return (out, pyaudio.paContinue)
''' DOCUMENTATION ''' # IMPORTS import entry as en import recording as rec import previous as prev import processing as proc # ENTRY POINT en.animate() ; # START RECORDING rec.record() # IMPORT PREVIOUS CALCULATIONS DATA prev.importPrevious() # BEGIN PROCESSING proc.processing() # DISPLAY RESULTS
import librosa
if __name__ == '__main__':
##VIRGINIE
db_path = input("enter location of the database: ")
database, songnames, songs = np.load(db_path)
##END VIRGINIE
try:
while True:
# Audio sample to be analyzed and identified
print(
'Please enter an audio sample file to identify. Press CTRL+C if you want to stop.'
)
userinput = record()
sample = librosa.load(userinput)
print('Analyzing the audio sample: ' + str(userinput))
hashSample = analyze_sample(sample)
print('Attempting to identify the sample audio clip.')
###VIRGINIE
index = song_id(hashSample, database, songs)
# Identify the song
print('The sample song is: ' + str(songnames[index]))
###END VIRGINIE
except KeyboardInterrupt:
import readDef
import tuling
import synthetic_voice
import hcsr04
import GP2D12
import hongwaibizhang
i = 1
name = [0 for p in range(100)]
while (True):
readDef.readDef("/home/pi/Desktop/chuangan/action/forward/zhanli.txt")
#录音
os.system("mplayer /home/pi/Desktop/ASR/pangbai/start.mp3")
print("************************开始*************************")
recording.record("test3.wav")
print("语音识别:")
#识别语音
ASR.stt('test3.wav', 'demo.txt')
print("txt文件生成")
f = open("demo.txt") # 返回一个文件对象
statement = f.read()
print(statement)
f.close()
pattern = r"人机互动"
m1 = re.search(pattern, statement)
if m1 != None:
print("1.人机互动")
print("人机互动开始")
from std_msgs.msg import String
from recording import record
czasMowy = 4
numberOfWavFiles = 1
if __name__ == "__main__":
pub = rospy.Publisher('recorder', String, queue_size=10)
rospy.init_node('rec', anonymous=True)
rate = rospy.Rate(10) # 10hz
while not rospy.is_shutdown(): #While(True)
record(czasMowy,numberOfWavFiles)
print numberOfWavFiles
rospy.loginfo(numberOfWavFiles)
print (" ")
pub.publish(str(numberOfWavFiles))
rate.sleep()
if (numberOfWavFiles >=5):
numberOfWavFiles = 1
else:
numberOfWavFiles += 1
# -*- coding: utf-8 -*-
import recording as rec
import process_images as p_i
import report
import time
path = 'sct2\\'
c = input(
'Mode: [1] = recording | [2] = creating abc-notation from recorded images | [3] creating abc_notation from datafile\n'
)
if c == '1':
length = input('Length in seconds: ')
if length.isnumeric():
rec.prepare(path)
rec.record(length, path) # time in seconds
else:
print('expected int')
elif c == '2' or c == '3':
title = input("Enter the title: ")
composer = input("Enter the composer: ")
start_time = time.time()
# In Process_Images auswählen, ob man Bilder einlesen möchte oder nicht.
score_object = p_i.create_score_object(path,
use_images=c == '2',
title=title,
composer=composer)
outputstr = score_object.convert_to_abc()
#Program do wysyłania
import json, subprocess, rospy, re, urllib, pycurl, os, sys, time, numpy
from std_msgs.msg import String
from recording import record
czasMowy = 4
numberOfWavFiles = 1
if __name__ == "__main__":
pub = rospy.Publisher('recorder', String, queue_size=10)
rospy.init_node('rec', anonymous=True)
rate = rospy.Rate(10) # 10hz
while not rospy.is_shutdown(): #While(True)
record(czasMowy, numberOfWavFiles)
print numberOfWavFiles
rospy.loginfo(numberOfWavFiles)
print(" ")
pub.publish(str(numberOfWavFiles))
rate.sleep()
if (numberOfWavFiles >= 5):
numberOfWavFiles = 1
else:
numberOfWavFiles += 1
