def play_audio(audio, start=0, stop=None, save=None, batch_size=1024): player = pyaudio.PyAudio() if isinstance(audio, str): input_stream = wave.openfp(open(audio, 'rb')) else: input_stream = wave.openfp(BytesIO(audio.get_wav_data())) output_stream = player.open( format=player.get_format_from_width(input_stream.getsampwidth()), channels=input_stream.getnchannels(), rate=input_stream.getframerate(), output=True) # play stream batch = input_stream.readframes(batch_size) save = open(save, 'wb') if save is not None else save i = 0 while batch and (i + 1) * batch_size >= start and (stop is None or (i - 1) * batch_size < stop): if stop is not None and i * batch_size >= stop: batch = batch[:(stop % batch_size)] if start and i * batch_size < start: batch = batch[(start % batch_size):] output_stream.write(batch) if save is not None: save.write(batch) batch = input_stream.readframes(batch_size) return audio
def getEmbedding(filenames): #the output is a list of files output = [] #find the shortest file length for file in filenames: a = wave.openfp(file, mode="rb") try: shortest except NameError: var_exists = False else: var_exists = True if not var_exists: shortest = a.getnframes() else: if (shortest > a.getnframes()): shortest = a.getnframes() #embed each file at the shortest length for file in filenames: a = wave.openfp(file, mode="rb") b = a.readframes(shortest) output.append(b) return output
def fetchDataAndlabels(train_files,annotation,classes): Y = [] X = [] for filename in train_files: w = wv.read(filename) w_ = wave.openfp(filename) maxval = 2 ** ((w_.getsampwidth() * (8) - 1)) fs = w[0] audioData = w[1] audioData = audioData / maxval audioData = (audioData + 1) / 2 head_tail = os.path.split(filename) A = annotation[annotation[:, 0] == head_tail[1], :] for row in A: mLabel = row[1] startA = int(row[2]) stopA = int(row[3]) for i in range(startA, (stopA - 4000), 100): c = classes.index(mLabel) Y.append(c) # print(c) dat = np.asarray(audioData[i:i + 4000]) # dat= (dat+np.ones(np.shape(dat)))/2 dat.resize((1, 250, 16)) X.append(dat) # X=np.concatenate((X,dat),axis=0) # print('ok') return X,Y
def split_wav(self, mode): import io import wave segments_file = self.recipe_path.joinpath("data", mode, "segments") logger.info(f"processing {str(segments_file)} file ...") segments = dict() with smart_open(segments_file, "r") as f: for line in tqdm(f, total=get_num_lines(segments_file), ncols=params.NCOLS): split = line.strip().split() uttid, wavid, start, end = split[0], split[1], float( split[2]), float(split[3]) if wavid in segments: segments[wavid].append((uttid, start, end)) else: segments[wavid] = [(uttid, start, end)] wav_scp = self.recipe_path.joinpath("data", mode, "wav.scp") logger.info(f"processing {str(wav_scp)} file ...") manifest = dict() with smart_open(wav_scp, "r") as rf: for line in tqdm(rf, total=get_num_lines(wav_scp), ncols=params.NCOLS): wavid, cmd = line.strip().split(" ", 1) if not wavid in segments: continue cmd = cmd.strip().rstrip(' |').split() if cmd[0] == 'sph2pipe': cmd[0] = str(SPH2PIPE_PATH) p = sp.run(cmd, stdout=sp.PIPE, stderr=sp.PIPE) fp = io.BytesIO(p.stdout) with wave.openfp(fp, "rb") as wav: fr = wav.getframerate() nf = wav.getnframes() for uttid, start, end in segments[wavid]: fs, fe = int(fr * start - SAMPLE_MARGIN), int(fr * end + SAMPLE_MARGIN) if fs < 0 or fe > nf: continue wav.rewind() wav.setpos(fs) signal = wav.readframes(fe - fs) p = uttid.find('-') if p != -1: tar_path = self.target_path.joinpath( mode, uttid[:p]) else: tar_path = self.target_path.joinpath(mode) tar_path.mkdir(mode=0o755, parents=True, exist_ok=True) wav_file = tar_path.joinpath(uttid + ".wav") with wave.open(str(wav_file), "wb") as wf: wf.setparams(wav.getparams()) wf.writeframes(signal) manifest[uttid] = (str(wav_file), fe - fs) return manifest
def test_wav(h, f): import wave if not h.startswith(b'RIFF') or h[8:12] != b'WAVE' or h[12:16] != b'fmt ': return None f.seek(0) try: w = wave.openfp(f, 'r') except (EOFError, wave.Error): return None return 'wav', w.getframerate(), w.getnchannels(), w.getnframes( ), 8 * w.getsampwidth()
def process_text_only(self, mode): import wave logger.info(f"processing text only from \"{mode}\" ...") wav_manifest = dict() for wav_file in self.target_path.joinpath(mode).rglob("*.wav"): uttid = wav_file.stem with wave.openfp(str(wav_file), "rb") as wav: samples = wav.getnframes() wav_manifest[uttid] = (str(wav_file), samples) txt_manifest = self.get_transcripts(mode) self.make_manifest(mode, wav_manifest, txt_manifest)
def test_wav(h, f): import wave # 'RIFF' <len> 'WAVE' 'fmt ' <len> if not h.startswith(b"RIFF") or h[8:12] != b"WAVE" or h[12:16] != b"fmt ": return None f.seek(0) try: w = wave.openfp(f, "r") except (EOFError, wave.Error): return None return ("wav", w.getframerate(), w.getnchannels(), w.getnframes(), 8 * w.getsampwidth())
def test_wav(h, f): import wave # 'RIFF' <len> 'WAVE' 'fmt ' <len> if not h.startswith(b'RIFF') or h[8:12] != b'WAVE' or h[12:16] != b'fmt ': return None f.seek(0) try: w = wave.openfp(f, 'r') except (EOFError, wave.Error): return None return ('wav', w.getframerate(), w.getnchannels(), w.getnframes(), 8*w.getsampwidth())
def convertToWave(self): output = self.combineChannels() outs = [] for x in range(0, len(output)): outs.append(struct.pack('f', output[x])) self.name = ''.join([self.name, ".wav"]) wav = w.openfp(self.name, 'w') wav.setparams((1, 4, 44100, len(outs), "NONE", "")) out_str = ''.join(outs) wav.writeframes(out_str) wav.close() return
def rebuild(self, mode): import wave logger.info(f"rebuilding \"{mode}\" ...") wav_manifest, txt_manifest = dict(), dict() for wav_file in self.target_path.joinpath(mode).rglob("*.wav"): uttid = wav_file.stem with wave.openfp(str(wav_file), "rb") as wav: samples = wav.getnframes() wav_manifest[uttid] = (str(wav_file), samples) txt_file = str(wav_file).replace('wav', 'txt') if Path(txt_file).exists(): txt_manifest[uttid] = (str(txt_file), '-') self.make_manifest(mode, wav_manifest, txt_manifest)
def play_audio(audio): p = pyaudio.PyAudio() f = wave.openfp(BytesIO(audio.get_wav_data())) stream = p.open(format=p.get_format_from_width(f.getsampwidth()), channels=f.getnchannels(), rate=f.getframerate(), output=True) # play stream data = f.readframes(1024) while data: stream.write(data) data = f.readframes(1024)
def rc4_wave(key, input_filename, output_filename): ''' encrypts/decrypts the wave input file to the wave output file file using the key (string, string, string) -> None ''' # change key into byte form key_b = utf82bytes(key) # use wave.openfp() to open inputfile and outputfile myfile = wave.openfp(input_filename, 'rb') newfile = wave.openfp(output_filename, 'wb') # use getparams() to get the header part header = myfile.getparams() # use getnframes() to get the number of frames n = myfile.getnframes() # use readframes() to find the plaintext plaintext_b = myfile.readframes(n) # setparams with header so the outputfile is playable newfile.setparams(header) # use rc4 to en/decrypt data and write into outputfile data = rc4(key_b, plaintext_b) newfile.writeframes(data) # close files myfile.close() newfile.close()
def file_open(self): try: self.file = QFileDialog.getOpenFileName(self,"Open File", os.getcwd(), 'WAV(*.wav)') self.wave = wave.openfp(self.file[0], 'rb') self.show_info() with self.wave: self.plotMenu.setEnabled(True) self.statusBar().showMessage("Wczytano plik!") self.show_info self.sound = QSound(self.file[0]) self.show_player() except FileNotFoundError: print('Nie udało się otworzyć pliku!')
def read_from_byte_string(byte_string, dtype=np.dtype('<i2')): """ Parses a bytes string, i.e. a raw read of a wav file :param byte_string: input bytes string :param dtype: dtype used to decode the audio data :return: np.ndarray with audio data with channels x samples """ wav_file = wave.openfp(BytesIO(byte_string)) channels = wav_file.getnchannels() interleaved_audio_data = np.frombuffer(wav_file.readframes( wav_file.getnframes()), dtype=dtype) audio_data = np.array( [interleaved_audio_data[ch::channels] for ch in range(channels)]) audio_data = audio_data.astype(np.float32) / np.max(audio_data) return audio_data
def split_wav(mode, target_dir): import io import wave data_dir = Path(ASPIRE_ROOT, "data", mode).resolve() segments_file = Path(data_dir, "segments") logger.info(f"processing {str(segments_file)} file ...") segments = dict() with smart_open(segments_file, "r") as f: for line in tqdm(f, total=get_num_lines(segments_file)): split = line.strip().split() uttid, wavid, start, end = split[0], split[1], float(split[2]), float(split[3]) if wavid in segments: segments[wavid].append((uttid, start, end)) else: segments[wavid] = [(uttid, start, end)] wav_scp = Path(data_dir, "wav.scp") logger.info(f"processing {str(wav_scp)} file ...") manifest = dict() with smart_open(wav_scp, "r") as f: for line in tqdm(f, total=get_num_lines(wav_scp)): wavid, cmd = line.strip().split(" ", 1) if not wavid in segments: continue cmd = cmd.strip().rstrip(' |').split() p = sp.run(cmd, stdout=sp.PIPE, stderr=sp.PIPE) fp = io.BytesIO(p.stdout) with wave.openfp(fp, "rb") as wav: fr = wav.getframerate() nf = wav.getnframes() for uttid, start, end in segments[wavid]: fs, fe = int(fr * start - SAMPLE_MARGIN), int(fr * end + SAMPLE_MARGIN) if fs < 0 or fe > nf: continue wav.rewind() wav.setpos(fs) signal = wav.readframes(fe - fs) tar_dir = Path(target_dir) / uttid[6:9] Path(tar_dir).mkdir(mode=0o755, parents=True, exist_ok=True) wav_file = str(Path(tar_dir, uttid + ".wav")) with wave.open(wav_file, "wb") as split_wav: split_wav.setparams(wav.getparams()) split_wav.writeframes(signal) manifest[uttid] = (wav_file, fe - fs) return manifest
def _Load(self): # open file finder dialog UI root = Tk() root.filename = tkFileDialog.askopenfilename() if not root.filename: print('Invalid file') root.destroy() return False print(root.filename) # read the selected file audioFile = wave.openfp(root.filename, 'rb') self.ui.fs = audioFile.getframerate() #get fs n = audioFile.getnframes() # get length data = np.frombuffer(audioFile.readframes(n), dtype=np.int16) self.ui.Recording = data # insert audio into our recording print("Recording Loaded successfully") root.destroy() return True
def reconstruct_manifest(target_dir): import wave logger.info("reconstructing manifest files ...") with open(Path(target_dir, "train.csv"), "w") as f1: with open(Path(target_dir, "dev.csv"), "w") as f2: for wav_file in Path(target_dir).glob("**/*.wav"): uttid = wav_file.stem txt_file = str(wav_file).replace("wav", "txt") phn_file = str(wav_file).replace("wav", "phn") if not Path(txt_file).exists() or not Path(phn_file).exists(): continue with wave.openfp(str(wav_file), "rb") as wav: samples = wav.getnframes() num_frms = get_num_lines(phn_file) if 0 < int(uttid[6:11]) < 60: f2.write(f"{uttid},{wav_file},{samples},{phn_file},{num_frms},{txt_file}\n") else: f1.write(f"{uttid},{wav_file},{samples},{phn_file},{num_frms},{txt_file}\n") logger.info("data preparation finished.")
# -*- coding: utf-8 -*- """ Created on Sun Oct 9 11:35:30 2016 @author: evert """ #from pylab import * from scipy.io import wavfile import matplotlib.pyplot as plt from scipy.signal import butter, lfilter import numpy as np import struct import wave file = wave.openfp('evert.wav', 'wb') #Wave_write.setparams(tuple) #The tuple should be (nchannels, sampwidth, framerate, nframes, comptype, compname), with values valid for the set*() methods. Sets all parameters. file.setparams((1, 2, 44100, 0, 'NONE', 'not compressed')) for i in range(0, 1000): value = np.mod(i, 200) - 100 packed_value = struct.pack('h', value) file.writeframes(packed_value) #file.writeframes(packed_value) file.close()
#!/usr/bin/env python # -*- coding: utf-8 -*- import wave, Image f = [wave.openfp('waves/lake%d.wav'%i,'rb') for i in range(1,26)] # tous les .wav font 10800 frames en mono nbframes = f[0].getnframes() w = 60 h = nbframes/3/w dst = Image.new('RGB',(5*w,5*h)) pix = dst.load() for i in range(5): for j in range(5): n = 5*j+i dx = w*i dy = h*j for y in range(h): for x in range(w): pix[x+dx,y+dy] = (ord(f[n].readframes(1)),ord(f[n].readframes(1)),ord(f[n].readframes(1))) for w in f: w.close() dst.save('dst.png')
# too long to display (unless you display only some of the elements ...) #If a plot shows up solid color, do (t[:100], (variable)[:100]) to see values better ## DISABLED PLOTTING TO SPEED UP PROGRAM ########## plt.plot(t, adjustedADSR_Signal) plt.show() ########## SCALING TO WRITE WAV FILES ####################### # range -32768 to 32767 and cast to 16-bit integers as so: adsr_scaled = np.int16(adjustedADSR_Signal * maxInt) ####################################################### ############ WRITING THE WAV FILES ################### ####################################################### ######## ADSR ENVELOPE ######## adsr = wave.openfp('adjustedADSR.wav', 'wb') adsr.setnframes(samplesPerSec) adsr.setsampwidth(2) #amount of bytes, 8bits/byte adsr.setnchannels(1) #mono-1 stereo-2 adsr.setframerate(samplesPerSec) adsr_data = adsr_scaled adsr.writeframesraw(adsr_data) adsr.close() ################################################ ############# PLaying Audio in real time ####### ################################################ chunk = 1024 adsr_play = wave.open('adjustedADSR.wav', 'rb') p = pyaudio.PyAudio()
maxInt=32767.0 #Max number of 16 bits t = np.float32(np.arange(0, numOfSecs*samplesPerSec, dtype=float))/samplesPerSec squareSig=(np.greater(np.sin(2*pi*t*freq),0,))*1 ########## SCALING TO WRITE WAV FILES ####################### # range -32768 to 32767 and cast to 16-bit integers as so: scaledSquare=np.int16(squareSig*maxInt) ####################################################### ########## WRITING THE WAV FILES ###################### ####################################################### ###### Square wave ################ ##Be sure to time numOfSecs=10 to hear it square=wave.openfp('sampleSquare.wav','wb') square.setnframes(samplesPerSec) square.setsampwidth(2) square.setnchannels(1) #mono square.setframerate(samplesPerSec) s = scaledSquare square.writeframesraw(s) square.close() ################################################ ############# PLaying Audio in real time ####### ################################################ chunk=1024 square_play=wave.open('sampleSquare.wav','rb') p=pyaudio.PyAudio()
upAmp = [ t / (numOfSecs * samplesPerSec) for t in range(int((numOfSecs * samplesPerSec))) ] #getting equal intervals of 1/Hz myUpSig = upAmp * np.sin(2 * pi * freq * t) #for linearity ########## SCALING TO WRITE WAV FILES ####################### # range -32768 to 32767 and cast to 16-bit integers as so: scaledUp = np.int16(myUpSig * maxInt) ####################################################### ########## WRITING THE WAV FILES ###################### ####################################################### ###### Ramp of sine function (Amp. Increasing.) ########## fw2 = wave.openfp('sampleSinRamp.wav', 'wb') fw2.setnframes(samplesPerSec) fw2.setsampwidth(2) fw2.setnchannels(1) #mono fw2.setframerate(samplesPerSec) data2 = scaledUp fw2.writeframesraw(data2) fw2.close() ################################################ ############# PLaying Audio in real time ####### ################################################ chunk = 1024 ramp_play = wave.open('sampleSinRamp.wav', 'rb') p = pyaudio.PyAudio()
""" #from pylab import * from scipy.io import wavfile import matplotlib.pyplot as plt from scipy.signal import butter, lfilter import numpy as np import struct import wave Fs, snd = wavfile.read('MorseCode/160105_40WPM.wav') snd = snd[:1e6] file = wave.openfp('MorseCode/160105_40WPM_C.wav', 'wb') #Wave_write.setparams(tuple) #The tuple should be (nchannels, sampwidth, framerate, nframes, comptype, compname), with values valid for the set*() methods. Sets all parameters. plt.plot(snd) plt.show() file.setparams((1, 2, Fs, 0, 'NONE', 'not compressed')) for i in range(0, snd.size): value = snd[i] packed_value = struct.pack('h', value) file.writeframes(packed_value) #file.writeframes(packed_value)
def reg(self, filename): #获取token requestData = { "grant_type": self.Grant_type, "client_id": self.Api_Key, "client_secret": self.Secrect_Key } result = requests.post(url=self.Token_url, data=requestData) token_data = json.loads(result.text) #self.Print_Response(token_data) if 'access_token' in token_data: token = token_data['access_token'] #获取的token rospy.loginfo('token获取成功\n') else: rospy.loginfo('token获取失败\n') #提交数据 file_path = self.current_path() WAVE_FILE = '%s/%s.%s' % (file_path, filename, self.FORMAT) rospy.loginfo('uploading file : %s \n' % WAVE_FILE) f = wave.openfp(WAVE_FILE, "rb") params = f.getparams() nchannels, sampwidth, framerate, nframes = params[:4] str_data = f.readframes( nframes ) #Reads and returns at most n frames of audio, as a string of bytes #print str_data,type(str_data) f.close() speech = base64.b64encode(str_data) size = len(str_data) #print 'size',size RegData = { "format": self.FORMAT, "rate": framerate, "channel": nchannels, "cuid": self.USER_ID, "token": token, "len": size, "speech": speech, "lan": self.LAN } HTTP_HEADER = { 'Content-Type': 'audio/%s;rate=%s' % (self.FORMAT, framerate), 'Content-length': len(json.dumps(RegData)) } r = requests.post(url=self.Reg_url, data=json.dumps(RegData, sort_keys=True), headers=HTTP_HEADER) #print json.dumps(RegData, sort_keys=True),type(json.dumps(RegData, sort_keys=True)) rospy.loginfo('response header') self.Print_Response(r.headers) rospy.loginfo('response header\n') #处理JSON result = json.loads(r.text) #self.Print_Response(result) rospy.loginfo('result: %s \n' % result['err_msg']) #,type(result) if result[u'err_msg'] == 'success.': word = result['result'][0].encode('utf-8') if word != '': if word[len(word) - 3:len(word)] == ',': rospy.loginfo('识别结果: %s \n' % word[0:len(word) - 3]) return word[0:len(word) - 3] else: rospy.loginfo(word) return word else: rospy.loginfo("音频文件不存在或格式错误\n") return '音频文件不存在或格式错误' else: rospy.loginfo(self.error_reason[result[u'err_no']]) return self.error_reason[result[u'err_no']]
#!/usr/bin/env python # -*- coding: utf-8 -*- import urllib2, base64, wave, array url = 'http://www.pythonchallenge.com/pc/hex/bin.html' auth_handler = urllib2.HTTPBasicAuthHandler() auth_handler.add_password(realm='pluses and minuses',uri=url,user='******',passwd='fly') opener = urllib2.build_opener(auth_handler) f = open('indian.wav','w') f.write(base64.standard_b64decode(''.join(opener.open(url).readlines()[27:-4]))) f.close() print 'inverted India => inverted endian' src = wave.openfp('indian.wav','rb') dst = wave.openfp('naidni.wav','wb') dst.setparams(src.getparams()) ## Cette ligne renvoie le bon fichier mais avec le son lu à l'envers ! #dst.writeframes(src.readframes(src.getnframes())[::-1]) ## La bonne solution est de renverser chaque octet : a = array.array('i') a.fromstring(src.readframes(src.getnframes())) a.byteswap() dst.writeframes(a.tostring()) src.close() dst.close()
#print("Maximum value in signal is " + np.max(mySignal).astype('str')) #print("Minimum value in signal is " + np.min(mySignal).astype('str')) ########## SCALING TO WRITE WAV FILES ####################### # range -32768 to 32767 and cast to 16-bit integers as so: scaled = np.int16(mySignal * maxInt) scaledOdd = np.int16(myOddSig * maxInt) scaledUp = np.int16(myUpSig * maxInt) scaledSquare = np.int16(squareSig * maxInt) ####################################################### ########## WRITING THE WAV FILES ###################### ####################################################### ######## Basic sine wave ######## fw = wave.openfp('sampleSin.wav', 'wb') fw.setnframes(samplesPerSec) fw.setsampwidth(2) #amount of bytes, 8bits/byte fw.setnchannels(1) #mono-1 stereo-2 fw.setframerate(samplesPerSec) data = scaled fw.writeframesraw(data) fw.close() ###### Ramp of sine function (Amp. Increasing.) ########## fw2 = wave.openfp('sampleSinRamp.wav', 'wb') fw2.setnframes(samplesPerSec) fw2.setsampwidth(2) fw2.setnchannels(1) #mono fw2.setframerate(samplesPerSec) data2 = scaledUp
# too long to display (unless you display only some of the elements ...) #If a plot shows up solid color, do (t[:100], (variable)[:100]) to see values better ## DISABLED PLOTTING TO SPEED UP PROGRAM ########## plt.plot(t, myADSR_Signal) plt.show() ########## SCALING TO WRITE WAV FILES ####################### # range -32768 to 32767 and cast to 16-bit integers as so: adsr_scaled = np.int16(myADSR_Signal * maxInt) ####################################################### ############ WRITING THE WAV FILES ################### ####################################################### ######## ADSR ENVELOPE ######## adsr = wave.openfp('sampleADSR.wav', 'wb') adsr.setnframes(samplesPerSec) adsr.setsampwidth(2) #amount of bytes, 8bits/byte adsr.setnchannels(1) #mono-1 stereo-2 adsr.setframerate(samplesPerSec) adsr_data = adsr_scaled adsr.writeframesraw(adsr_data) adsr.close() ################################################ ############# PLaying Audio in real time ####### ################################################ chunk = 1024 adsr_play = wave.open('sampleADSR.wav', 'rb') p = pyaudio.PyAudio()
total_cm = np.array([[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]) fld = 0 #number of fold for train_fnms, test_fnms in KFold( 5, True).split(filenames): #loop to perform 5-fold cross validation fld += 1 print('Number of fold: ', fld) train_files = [filenames[i] for i in train_fnms] test_files = [filenames[i] for i in test_fnms] for filename in train_files: ind = ind + 1 #print(ind) w = scipy.io.wavfile.read(filename) w_ = wave.openfp(filename) maxval = 2**((w_.getsampwidth() * (8) - 1)) fs = w[0] audioData = w[1] audioData = audioData / maxval audioData = (audioData + 1) / 2 head_tail = os.path.split(filename) A = annotation[annotation[:, 0] == head_tail[1], :] for row in A: mLabel = row[1] startA = int( row[2]) #sample from which the respiratory phase begins stopA = int(row[3]) #sample at which the respiratory phase stops for i in range( startA, (stopA - 4000), 500 ): #loop to slide a window of size 4000 with step of 500 samples. There is an overlapping of 3500 samples.
t = np.float32(np.arange(0, numOfSecs * samplesPerSec, dtype=float)) / samplesPerSec mySignal = np.sin(2 * pi * t * freq) ########## SCALING TO WRITE WAV FILES ####################### # range -32768 to 32767 and cast to 16-bit integers as so: scaled = np.int16(mySignal * maxInt) ####################################################### ########## WRITING THE WAV FILES ###################### ####################################################### ######## Basic sine wave ######## fw = wave.openfp('sampleSin.wav', 'wb') fw.setnframes(samplesPerSec) fw.setsampwidth(2) #amount of bytes, 8bits/byte fw.setnchannels(1) #mono-1 stereo-2 fw.setframerate(samplesPerSec) data = scaled fw.writeframesraw(data) fw.close() ################################################ ############# PLaying Audio in real time ####### ################################################ chunk = 1024 sin_play = wave.open('sampleSin.wav', 'rb') p = pyaudio.PyAudio()
maxInt=32767.0 #Max number of 16 bits t = np.float32(np.arange(0, numOfSecs*samplesPerSec, dtype=float))/samplesPerSec myOddSig= np.sin(2*pi*t*freq)+np.sin(2*pi*t*freq*3)/3 + np.sin(2*pi*t*freq*5)/5 + np.sin(2*pi*t*freq*7)/7 + np.sin(2*pi*t*freq*9)/9; ########## SCALING TO WRITE WAV FILES ####################### # range -32768 to 32767 and cast to 16-bit integers as so: scaledOdd=np.int16(myOddSig*maxInt) ####################################################### ########## WRITING THE WAV FILES ###################### ####################################################### ###### Odd (1,3,5,7,9) wave ################ ##Be sure to time numOfSecs=10 to hear it odd=wave.openfp('sampleOdd.wav','wb') odd.setnframes(samplesPerSec) odd.setsampwidth(2) odd.setnchannels(1) #mono odd.setframerate(samplesPerSec) dataOdd = scaledOdd odd.writeframesraw(dataOdd) odd.close() ################################################ ############# PLaying Audio in real time ####### ################################################ chunk=1024 odd_play=wave.open('sampleOdd.wav','rb') p=pyaudio.PyAudio()
def reg(self,filename): #获取token requestData = { "grant_type": self.Grant_type, "client_id": self.Api_Key, "client_secret": self.Secrect_Key} result = requests.post(url = self.Token_url, data = requestData) token_data = json.loads(result.text) #self.Print_Response(token_data) if 'access_token' in token_data: token = token_data['access_token'] #获取的token rospy.loginfo('token获取成功\n') else: rospy.loginfo('token获取失败\n') #提交数据 file_path=self.current_path() WAVE_FILE = '%s/%s.%s'%(file_path,filename,self.FORMAT) rospy.loginfo('uploading file : %s \n'%WAVE_FILE) f = wave.openfp(WAVE_FILE,"rb") params = f.getparams() nchannels, sampwidth, framerate, nframes = params[:4] str_data = f.readframes(nframes) #Reads and returns at most n frames of audio, as a string of bytes #print str_data,type(str_data) f.close() speech = base64.b64encode(str_data) size = len(str_data) #print 'size',size RegData = { "format": self.FORMAT, "rate": framerate, "channel": nchannels, "cuid": self.USER_ID, "token": token, "len": size, "speech": speech, "lan": self.LAN} HTTP_HEADER= { 'Content-Type': 'audio/%s;rate=%s'%(self.FORMAT,framerate), 'Content-length': len(json.dumps(RegData))} r = requests.post(url = self.Reg_url, data = json.dumps(RegData, sort_keys=True), headers=HTTP_HEADER) #print json.dumps(RegData, sort_keys=True),type(json.dumps(RegData, sort_keys=True)) rospy.loginfo('response header') self.Print_Response(r.headers) rospy.loginfo('response header\n') #处理JSON result = json.loads(r.text) #self.Print_Response(result) rospy.loginfo( 'result: %s \n'%result['err_msg'])#,type(result) if result[u'err_msg']=='success.': word = result['result'][0].encode('utf-8') if word!='': if word[len(word)-3:len(word)]==',': rospy.loginfo('识别结果: %s \n'%word[0:len(word)-3]) return word[0:len(word)-3] else: rospy.loginfo(word) return word else: rospy.loginfo("音频文件不存在或格式错误\n") return '音频文件不存在或格式错误' else: rospy.loginfo(self.error_reason[result[u'err_no']]) return self.error_reason[result[u'err_no']]
#mySignal = np.sin(2.0*np.pi*t*(fc + d*np.sin(2.0*np.pi*t*fm))) # This is tempting, but it is wrong ... #mySignal = np.sin(2.0*np.pi*fc*t - d/fm*np.cos(2.0*np.pi*t*fm)) # This is correct mySignal = np.sin( 2.0 * np.pi * randoms[0] * t + (randoms[1] / randoms[2]) * np.sin(2.0 * np.pi * t * randoms[2]) ) # This sounds almost the same and is a little more convenient # To actually write it to a wave file, the sound has to be scaled to the # range -32768 to 32767 and cast to 16-bit integers as so: scaled = np.int16(mySignal * 32767.0) ####################################################### ############ WRITING THE WAV FILES ################### ####################################################### ######## Fast Sine WAV File ######## arraySine = wave.openfp('arrayInputFM.wav', 'wb') arraySine.setnframes(fs) arraySine.setsampwidth(2) #amount of bytes, 8bits/byte arraySine.setnchannels(1) #mono-1 stereo-2 arraySine.setframerate(fs) arraySine.writeframesraw(scaled) arraySine.close() ################################################ ############# PLaying Audio in real time ####### ################################################ chunk = 1024 arraySin_play = wave.open('arrayInputFM.wav', 'rb') p = pyaudio.PyAudio() stream = p.open(format=p.get_format_from_width(arraySin_play.getsampwidth()),
import pyaudio import numpy as np import scipy.signal import math import numbers import cmath import wave #commnds to make a line breakpoint #print ("this is a breakin line point",) #breakin = int(input()) wf = wave.openfp("/home/tony/Downloads/jimi2.wav", "rb") print ("Please give the gain:",) gain = np.double(input()) print ("Please give the mix:",) mix = np.double(input()) #defining audio parameters------------------------------------- CHUNK = 1024 FORMAT = pyaudio.paInt16 WIDTH = 2 DTYPE = np.int16 MAX_INT = 32768.0 CHANNELS = 2 RATE = 44100 #RATE = 22050 RECORD_SECONDS = 20 #audio streamming------------------------------------------------------------------------ p = pyaudio.PyAudio() print("* recording") number_loops=int(RATE / CHUNK * RECORD_SECONDS)
def ReadAudioFile(path): audioFile = wave.openfp(path, 'rb') fs = audioFile.getframerate() #get fs n = audioFile.getnframes() # get length data = np.frombuffer(audioFile.readframes(n), dtype=np.int16) return fs, data