def start():
print('=== 现在开始录音 ===')
# Recording duration
duration = 10
# Start recorder with the given values
# of duration and sample frequency
recording = sd.rec(int(duration * freq), samplerate=freq, channels=1)
# Record audio for the given number of seconds
sd.wait()
# This will convert the NumPy array to an audio
# file with the given sampling frequency
# write("recording0.wav", freq, recording)
# Convert the NumPy array to audio file
wv.write("test_in.wav", recording, freq, sampwidth=2)
print('=== 现在结束录音 ===')
os.system("python connect_api.py > out.txt")
os.system("python print_accuracy.py")
def process_single_file(self, file_name):
mixture, _ = load(os.path.join(self.input_dir, file_name + '.wav'),
sr=self.samplerate_hz)
speaker_signals = self.separate_single_mixture(mixture)
write_wav(os.path.join(self.output_dir, 's1', file_name + '.wav'), \
speaker_signals[0, :], self.samplerate_hz, norm=True)
wav, _ = np.array(
librosa.load(
os.path.join(self.output_dir, 's1', file_name + '.wav'),
22050))
wavio.write(os.path.join(self.output_dir, 's1', file_name + '.wav'),
wav,
22050,
sampwidth=3)
write_wav(os.path.join(self.output_dir, 's2', file_name + '.wav'), \
speaker_signals[1, :], self.samplerate_hz, norm=True)
wav, _ = np.array(
librosa.load(
os.path.join(self.output_dir, 's2', file_name + '.wav'),
22050))
wavio.write(os.path.join(self.output_dir, 's2', file_name + '.wav'),
wav,
22050,
sampwidth=3)
def major_scale(A4=440, waveform='square', mode='fixed'):
'''
Simple demo playing the major scale, given the root note.
'''
# You can use fixed frequencies, or calculate the
# corresponding ones for each note/tone.
if mode == 'fixed':
C_major = [
261.63, 293.66, 329.63, 349.23, 392.00, 440.00, 493.88, 523.25
]
elif mode == "dynamic":
# A tool for calculating a note's frequency is now implemented.
# Include this functionality here.
pass
else:
print('Mode not supported')
sys.exit()
if waveform == 'square':
generator = SquareGenerator(duration=1)
elif waveform == 'saw':
generator = SawGenerator(duration=1)
else:
print('Waveform generator not supported.')
sys.exit()
scale = []
for frequency in C_major:
scale = np.concatenate((scale, generator.generate(frequency)), axis=0)
wavio.write('generated_demos/c_major_scale_' + waveform + '.wav',
scale,
generator.rate,
sampwidth=SAMPWIDTH)
def record_and_recognize_song():
print("Listening!")
# arduino.write(bytes("Listening", 'utf-8'))
fs = 44100 # Sample rate
seconds = 5 # Duration of recording
myrecording = sd.rec(int(seconds * fs), samplerate=fs, channels=1)
sd.wait() # Wait until recording is finished
write('output1.wav', fs, myrecording) # Save as WAV file
wavio.write("myfile1.wav", myrecording, fs, sampwidth=2)
sound = AudioSegment.from_wav('myfile1.wav')
sound.export('myfile.mp3', format='mp3')
mp3_file_content_to_recognize = open('myfile.mp3', 'rb').read()
shazam = Shazam(mp3_file_content_to_recognize)
recognize_generator = shazam.recognizeSong()
song = None
while song is None:
song = next(recognize_generator)
print(song)
title = song[1]['track']['title']
artist = song[1]['track']['subtitle']
print(artist, title)
os.remove("myfile.mp3")
os.remove("myfile1.wav")
os.remove("output1.wav")
return artist, title
def save(self, wav_file: Path = "SpectroGraphic.wav"):
"""saves the spectrographic to a .wav file
We use the wavio module
"""
wavio.write(wav_file, self.sound_array, self.SAMPLE_RATE)
def main():
y1, s1 = librosa.load("audio1.wav")
y2, s2 = librosa.load("audio2.wav") # might need FFMPEG for this!!!
plt.plot(y1)
plt.show()
length = len(y1)/s1
plt.plot(y1)
plt.xlim((0.5/length)*len(y1), (1/length)*len(y1))
plt.show()
interval = 100 # ms
# create a sum of 2 signals
if len(y2) < len(y1):
y3 = y1.copy()
y3[:len(y2)] += y2
else:
y3 = y2.copy()
y3[:len(y1)] += y1
func1(interval, y1, s1)
func1(interval, y2, s2)
func1(interval, y3, s2)
w.write("sum2.wav", y3, s2, sampwidth=3) # testing the sum
"""The dft of the speech is, of of course, much more complex and has many more frequencies in it while the
def demon_noise(signal, chunk, freq):
noise = list(chunks(signal, chunk))
noise = random.sample(noise, len(noise))
noise = np.concatenate(noise, axis=0)
path = 'noise.wav'
w.write("noise.wav", noise, freq, sampwidth=3)
return path
def read(infile, outfile):
samples = np.fromfile(infile, dtype='>i2')
if len(samples) % 2:
samples = samples[:-1]
samples = samples.reshape(len(samples) // 2, 2)
wavio.write(outfile, samples, FRAMERATE, sampwidth=2, scale='none')
def write_to_file(self, file):
"""Save file in a .wav format"""
wavio.write(file,
self.data,
self.fs,
scale='none',
sampwidth=self.bytes)
def doTheThing():
start = datetime.now()
print('doing the thing!')
fs=44100
duration = 5
myrecording = sd.rec(fs * duration, samplerate=fs, channels=2)
print("Recording Audio")
sd.wait()
wavio.write('temp.wav',myrecording,fs,sampwidth=2)
temp = os.path.join(os.path.dirname(os.path.realpath(__file__)), "temp.wav")
print(temp)
r = sr.Recognizer()
with sr.AudioFile(temp) as source:
audio = r.record(source)
try:
query = r.recognize_google(audio)
print(search(query))
print("Google Speech Recognition thinks you said " + query)
except sr.UnknownValueError:
print("Google Speech Recognition could not understand audio")
except sr.RequestError as e:
print("Could not request results from Google Speech Recognition service; {0}".format(e))
end = datetime.now()
elapsed = end - start
print('took about {} units of time'.format(elapsed.total_seconds()))
def Main():
verbose = True
audio_in_path = './test_samples/153036.m4a'
(data, sampleRate) = ExtractCompressedAudioNTS(audio_in_path)
rescale = 1/(rms(data)+1e-8)/16
data *= rescale
if verbose:
wavio.write('temp/loadcheck.wav', data,
sampleRate, (-1, 1), sampwidth=2)
noiseReduceData = NoiseReduction(data, sampleRate, verbose)
squawks = FindSquawks(noiseReduceData, sampleRate)
os.system('mkdir -p squawk')
index = 0
for s in sorted(squawks, key=lambda squawk: squawk['duration']):
sub = ExtractSquawkData(noiseReduceData, sampleRate, s)
print(json.dumps(s))
fileName = 'squawk/squawk%04d.wav' % index
wavio.write(fileName, sub, sampleRate, (-1, 1), sampwidth=2)
fileName = 'squawk/squawk%04d.json' % index
with open(fileName, 'w') as f:
f.write(json.dumps(s, sort_keys=True, indent=4))
index = index+1
def ExtractSquawks(dirName, fileName, meta):
global GSquawkIndex
GSquawkIndex=0
verbose = True
(data, sampleRate) = ExtractCompressedAudioNTS(dirName+'/'+fileName)
rescale = 1/(rms(data)+1e-8)/16
data *= rescale
if verbose:
wavio.write('temp/loadcheck.wav', data,
sampleRate, (-1, 1), sampwidth=2)
noiseReduceData = NoiseReduction(data, sampleRate, verbose)
squawks = FindSquawks(noiseReduceData, sampleRate)
print('Squawk count : %d\n' % len(squawks))
os.system('mkdir -p squawk')
for s in sorted(squawks, key=lambda squawk: squawk['duration']):
s['origin'] = fileName
index = GSquawkIndex
GSquawkIndex = GSquawkIndex+1
sub = ExtractSquawkData(noiseReduceData, sampleRate, s)
print(json.dumps(s))
wavName = 'squawk/squawk%04d.wav' % index
wavio.write(wavName, sub, sampleRate, (-1, 1), sampwidth=2)
jsonName = 'squawk/squawk%04d.json' % index
s.update(meta)
with open(jsonName, 'w') as f:
f.write(json.dumps(s, sort_keys=True, indent=4))
def wave(self,
filename: str,
key: int = CHROMATIC_SCALE,
note_duration: int = DEFAULT_NOTE_DURATION,
sample_rate: int = DEFAULT_SAMPLE_RATE) -> None:
"""Returns the hash as a wave file.
# Args
- *filename*: file path for the output wave file.
- *key*: integer (see constants) corresponding to the musical key.
- *note_duration*: duration of each note in seconds.
- *sample_rate*: sample rate for the output audio.
# Raises
A ValueError if the key argument has one or fewer notes or more than
twelve notes or if the sample_rate or note_duration are less than or
equal to zero.
"""
if filename == '':
raise FileNotFoundError('Empty filename not permitted')
wavio.write(
file=filename,
data=self.samples(key, note_duration, sample_rate),
rate=sample_rate,
sampwidth=2)
def gen_C0_IRs(out_dir,IRs=100,buffersize=int(12E3),rev_prob=0.1,types=['EXP','HARM','RAND'],
H=[16,32,64,81],passes=[1,2,3],harmonics=[1,2,4]):
if not os.path.exists(out_dir): os.makedirs(out_dir)
data = []
for i in range(IRs):
h = np.random.choice(passes)
new = [0 for j in range(buffersize)]
for y in range(h):
s = np.random.choice(types)
if s=='EXP':
print('EXP')
new = list(dsp.fade_out(dsp.impulse_exp(new),buffersize))
if s=='HARM':
print('HARM')
r = np.random.choice(harmonics)
for x in range(r):
new = list(dsp.fade_out(dsp.fft_high_pass(dsp.impulse_harm(new,H)),buffersize))
if s=='RAND':
print('RAND')
new = list(dsp.fade_out(dsp.impulse_rand(new),buffersize))
if np.random.choice([True,False],p=[2*rev_prob,1.0-2*rev_prob]):
new = new[::-1]
data += [dsp.fft_high_pass(new)]
j = 0
for i in range(len(data)):
if j%10==0: #make a new directory if needed
j,last_dir = 0,out_dir+'/'+str(i/10)+'/'
if not os.path.exists(last_dir):
os.makedirs(last_dir)
wavio.write(last_dir+'W'+str(j)+'.wav',data[i],len(data[i]),sampwidth=2)
j += 1
return True
def test4(self):
path = tempfile.mkdtemp()
filename = os.path.join(path, "test4data.wav")
data = np.zeros(32, dtype=np.int16)
data[1::4] = 10000
data[3::4] = -10000
wavio.write(filename, data, 44100, sampwidth=1)
try:
f = wave.open(filename, 'r')
self.assertEqual(f.getnchannels(), 1)
self.assertEqual(f.getsampwidth(), 1)
self.assertEqual(f.getframerate(), 44100)
f.close()
w = wavio.read(filename)
self.assertEqual(w.rate, 44100)
self.assertEqual(w.sampwidth, 1)
self.assertEqual(w.data.dtype, np.uint8)
self.assertEqual(w.data.shape, (32, 1))
expected = 128*np.ones_like(data, dtype=np.uint8).reshape(-1, 1)
expected[1::4, 0] = 255
expected[3::4, 0] = 0
np.testing.assert_equal(w.data, expected)
finally:
os.remove(filename)
os.removedirs(path)
def save(self, filename):
"""Save sound in computer.
:param: A name of the file to be saved.
:type: str
"""
wavio.write(filename, self.audio, self.sampling_ratio, sampwidth=2)
def test4(self):
path = tempfile.mkdtemp()
filename = os.path.join(path, "test4data.wav")
data = np.zeros(32, dtype=np.int16)
data[1::4] = 10000
data[3::4] = -10000
wavio.write(filename, data, 44100, sampwidth=1)
try:
f = wave.open(filename, 'r')
self.assertEqual(f.getnchannels(), 1)
self.assertEqual(f.getsampwidth(), 1)
self.assertEqual(f.getframerate(), 44100)
f.close()
w = wavio.read(filename)
self.assertEqual(w.rate, 44100)
self.assertEqual(w.sampwidth, 1)
self.assertEqual(w.data.dtype, np.uint8)
self.assertEqual(w.data.shape, (32, 1))
expected = 128*np.ones_like(data, dtype=np.uint8).reshape(-1, 1)
expected[1::4, 0] = 255
expected[3::4, 0] = 0
np.testing.assert_equal(w.data, expected)
finally:
os.remove(filename)
os.removedirs(path)
def create_16_bit_wav(songpath,outpath):
import wavio
from scipy.io import wavfile
rate, audio = wavfile.read(songpath)
wavio.write(outpath, audio.astype(np.int16), rate, sampwidth=2)
def get_shimmer_jitter_from_opensmile(audio, index, sr):
wavio.write(f'temp_{str(index)}.wav', audio, sr, sampwidth=3)
subprocess.call(
["SMILExtract", "-C", os.environ['OPENSMILE_CONFIG_DIR'] + "/IS10_paraling.conf", "-I",
f"temp_{str(index)}.wav", "-O",
f"temp_{str(index)}.arff"])
# Read file and extract shimmer and jitter features from the generated arff file
file = open(f"temp_{str(index)}.arff", "r")
data = file.readlines()
# First 3 values are title, empty line and name | Last 5 values are numeric data,
# and bunch of empty lines and unwanted text
# headers = data[3:-5]
headers = data[3:data.index('@data\n')]
headers = headers[:headers.index('@attribute class numeric\n')]
# Last line of data is where the actual numeric data is. It is in comma separated string format. After splitting,
# remove the first value which is name and the last value which is class
numeric_data = data[-1].split(',')[1:-1]
assert len(headers) == len(numeric_data), "Features generated from opensmile are not matching with its headers"
# data_needed = {x.strip(): float(numeric_data[e]) for e, x in enumerate(headers) if 'jitter' in x or 'shimmer' in x}
data_needed = [float(numeric_data[e]) for e, x in enumerate(headers) if 'jitter' in x or 'shimmer' in x]
# clean up all files
delete_file(f'temp_{str(index)}.wav')
delete_file(f'temp_{str(index)}.arff')
return data_needed
def save_audio(filename, audio, sample_rate=16000, sample_depth=2):
import wavio
save_audio = (audio * np.iinfo(np.int16).max).astype(np.int16)
wavio.write(filename,
save_audio,
sample_rate,
sampwidth=sample_depth,
scale='none')
def wavwrite(data, fs, bit, fname):
if USE_SCIPY:
outdata = ( data * 2**(bit-1) ).astype(sp.int16)
scipy.io.wavfile.write(fname, fs, outdata.T)
elif USE_WAVIO:
data_wavio = data * 2**(bit-1)
sampwidth = bit/8
wavio.write(fname, data_wavio, fs, sampwidth)
def record():
print("Startingggg!!!!")
record=sd.rec(int(duration*freq), samplerate=freq,channels=2)
sd.wait()
write('recorddata0.wav',freq,record)
wv.write('recording1.wav',record,freq,sampwidth=2)
print("Finished!!!")
def myRecording(self):
myrecording = sd.rec(int(self.time_duration * self.fs),
samplerate=self.fs,
channels=2)
print("Recording has started will last for ", self.time_duration)
sd.wait() # Wait until recording is finished
wv.write(self.storage_address, myrecording, self.fs,
sampwidth=2) # Save as WAV file
def save_audio(filename: str, audio: np.ndarray):
import wavio
save_audio = (audio * np.iinfo(np.int16).max).astype(np.int16)
wavio.write(filename,
save_audio,
pr.sample_rate,
sampwidth=pr.sample_depth,
scale='none')
def make_soundfile(hits, ITER, file_name):
f = 240.0 # sound frequency (Hz)
# Compute waveform samples
x, rate = make_muted_sine(hits, f, ITER)
# Write the samples to a file
wavio.write(f"{file_name}.wav", x, rate, sampwidth=3)
def get_remap(self, tobrml, tobrmr):
new_data = get_mat_value(tobrml, tobrmr)
wavio.write("remap.wav",
new_data,
rate=self.wave.rate,
sampwidth=self.wave.sampwidth)
return
def test1(self):
with temporary_filepath("test1data.wav") as filename:
wavio.write(filename, data1, 44100, sampwidth=3)
self.check_basic(filename, nchannels=1, sampwidth=3,
framerate=44100)
self.check_wavio_read(filename, rate=44100, sampwidth=3,
dtype=np.int32, shape=(len(data1), 1),
data=data1[:, None])
def export_morse_audio(self,
_word_,
file_name='morse_audio.wav',
frequency=450,
wpm=20):
import wavio
self._call_play_by_export = True
wave = self.play_morse_code(_word_, frequency, wpm)
wavio.write(file_name, wave, self._fs_, sampwidth=2)
def save_audio(path, array, sampling=44100, sampling_width=4):
"""
Parameters:
path (str): Path where to save the audio file.
array (np.array of floats): Array to be saved.
sampling (int): Sampling rate of the stream.
sampling_width (int): Sampling width of the stream.
"""
wavio.write(path, array, rate=sampling, sampwidth=sampling_width)
def __generateFile(self, path, sound):
# plt.title(os.path.basename(path))
# plt.plot(np.linspace(0, 1, len(sound)), sound)
# plt.grid(True)
# plt.xlabel('Seconds')
# plt.ylabel('Amplitude [dB]')
# plt.show()
wavio.write(path, sound, self.rate, sampwidth=1, scale=(self.min_scale, self.max_scale))
def generate_wav(audio, file_name, sample_rate=41000):
"""
Generate .wav file from recorded audio
:param audio: Numpy array of audio samples
:param file_name: File name
:param sample_rate: Audio sample rate. (Default = 41000)
:return: None
"""
wavio.write(file_name, audio, sample_rate, sampwidth=3)
def save_selected_sound(audiodata, sampleRate, t1, t2, filename):
# t1, t2 in seconds
t1 = math.floor(t1 * sampleRate)
t2 = math.floor(t2 * sampleRate)
wavio.write(str(filename) + '.wav',
audiodata[int(t1):int(t2)].astype('int16'),
sampleRate,
scale='dtype-limits',
sampwidth=2)
def write_mungo(out_dir,
data,
module='G0',
prefix={'G0':'W','S0':'S','C0':'W','W0':'W'}):
if not os.path.exists(out_dir): os.makedirs(out_dir)
j = 0
for i in range(len(data)):
if j%10==0: #make a new directory if needed
j,last_dir = 0,out_dir+'/'+str(i/10)+'/'
if not os.path.exists(last_dir):
os.makedirs(last_dir)
wavio.write(last_dir+prefix[module]+str(j)+'.wav',data[i],len(data[i]),sampwidth=2)
j += 1
return True
def gen_W0_WTs(out_dir,WTs=10,buffersize=int(4E3),C=[0,0,0,1,1,1],h_range=range(10),plot=False):
if not os.path.exists(out_dir): os.makedirs(out_dir)
data = []
for i in range(WTs):
h = h_range[i%(len(h_range))]
data += [dsp.nonlin_shape(buffersize,C,h,plot)]
j = 0
for i in range(len(data)):
if j%10==0: #make a new directory if needed
j,last_dir = 0,out_dir+'/'+str(i/10)+'/'
if not os.path.exists(last_dir):
os.makedirs(last_dir)
wavio.write(last_dir+'W'+str(j)+'.wav',data[i],len(data[i]),sampwidth=2)
j += 1
return True
def test1(self):
path = tempfile.mkdtemp()
filename = os.path.join(path, "test1data.wav")
wavio.write(filename, data1, 44100, sampwidth=3)
try:
f = wave.open(filename, 'r')
self.assertEqual(f.getnchannels(), 1)
self.assertEqual(f.getsampwidth(), 3)
self.assertEqual(f.getframerate(), 44100)
f.close()
w = wavio.read(filename)
self.assertEqual(w.rate, 44100)
self.assertEqual(w.sampwidth, 3)
self.assertEqual(w.data.dtype, np.int32)
self.assertEqual(w.data.shape, (len(data1), 1))
np.testing.assert_equal(w.data[:, 0], data1)
finally:
os.remove(filename)
os.removedirs(path)
def resample(dirName):
"""
Resample to avoid high frq noise
"""
for root, dirs, files in os.walk(str(dirName)):
for file in files:
if file.endswith('.wav'):
# go through each segment
file = root + '/' + file
wavobj = wavio.read(file)
audioData = wavobj.data
if audioData.dtype is not 'float':
audioData = audioData.astype('float') # / 32768.0
if np.shape(np.shape(audioData))[0] > 1:
audioData = np.squeeze(audioData[:, 0])
sampleRate = wavobj.rate
import librosa
if sampleRate != 16000:
audioData = librosa.core.audio.resample(audioData, sampleRate, 16000)
sampleRate = 16000
wavio.write(file[:-4] + '_down.wav', audioData.astype('int16'), sampleRate, scale='dtype-limits', sampwidth=2)
def test_clip(self):
path = tempfile.mkdtemp()
filename = os.path.join(path, "testdata.wav")
data = np.array([-100, 0, 100, 200, 300, 325])
wavio.write(filename, data, 44100, sampwidth=1, scale='none')
try:
f = wave.open(filename, 'r')
self.assertEqual(f.getnchannels(), 1)
self.assertEqual(f.getsampwidth(), 1)
self.assertEqual(f.getframerate(), 44100)
f.close()
w = wavio.read(filename)
self.assertEqual(w.rate, 44100)
self.assertEqual(w.sampwidth, 1)
self.assertEqual(w.data.dtype, np.uint8)
self.assertEqual(w.data.shape, (len(data), 1))
expected = np.array([0, 0, 100, 200, 255, 255],
dtype=np.uint8).reshape(-1, 1)
np.testing.assert_equal(w.data, expected)
finally:
os.remove(filename)
os.removedirs(path)
def test5(self):
path = tempfile.mkdtemp()
filename = os.path.join(path, "test5data.wav")
data = np.zeros(32, dtype=np.int16)
data[1::4] = 10000
data[3::4] = -10000
wavio.write(filename, data, 44100, sampwidth=2, scale='none')
try:
f = wave.open(filename, 'r')
self.assertEqual(f.getnchannels(), 1)
self.assertEqual(f.getsampwidth(), 2)
self.assertEqual(f.getframerate(), 44100)
f.close()
w = wavio.read(filename)
self.assertEqual(w.rate, 44100)
self.assertEqual(w.sampwidth, 2)
self.assertEqual(w.data.dtype, np.int16)
self.assertEqual(w.data.shape, (32, 1))
np.testing.assert_equal(w.data, data.reshape(-1, 1))
finally:
os.remove(filename)
os.removedirs(path)
def extractSegments(wavFile, destination, copyName, species):
"""
This extracts the sound segments given the annotation and the corresponding wav file. (Isabel's experiment data extraction)
"""
datFile=wavFile+'.data'
try:
wavobj = wavio.read(wavFile)
sampleRate = wavobj.rate
data = wavobj.data
if os.path.isfile(datFile):
with open(datFile) as f:
segments = json.load(f)
cnt = 1
for seg in segments:
if seg[0] == -1:
continue
if copyName: # extract all - extracted sounds are saved with the same name as the corresponding segment in the annotation (e.g. Rawhiti exp.)
filename = destination + '\\' + seg[4] + '.wav'
s = int(seg[0] * sampleRate)
e = int(seg[1] * sampleRate)
temp = data[s:e]
wavio.write(filename, temp.astype('int16'), sampleRate, scale='dtype-limits', sampwidth=2)
elif not species: # extract all - extracted sounds are saved with the original file name followed by an index starting 1
ind = wavFile.rindex('/')
filename = destination + '\\' + str(wavFile[ind + 1:-4]) + '-' + str(cnt) + '.wav'
cnt += 1
s = int(seg[0] * sampleRate)
e = int(seg[1] * sampleRate)
temp = data[s:e]
wavio.write(filename, temp.astype('int16'), sampleRate, scale='dtype-limits', sampwidth=2)
elif species == seg[4]: # extract only specific calls - extracted sounds are saved with with the original file name followed by an index starting 1
ind = wavFile.rindex('/')
ind2 = wavFile.rindex('\\')
filename = destination + '\\' + str(wavFile[ind2+1:ind]) + '-' + str(wavFile[ind + 1:-4]) + '-' + str(seg[4]) + '-' + str(cnt) + '.wav'
cnt += 1
s = int((seg[0]-1) * sampleRate)
e = int((seg[1]+1) * sampleRate)
temp = data[s:e]
wavio.write(filename, temp.astype('int16'), sampleRate, scale='dtype-limits', sampwidth=2)
except:
print ("unsupported file: ", wavFile)
def main():
files = [
# "/home/nhilton/development/nsound/src/examples/california.wav",
# "/home/nhilton/development/nsound/src/examples/mynameis.wav",
# "/home/nhilton/development/nsound/src/examples/Temperature_in.wav",
# "/home/nhilton/development/nsound/src/examples/walle.wav",
# "/home/nhilton/development/nsound/src/examples/example1",
# "empty.bin",
"chirp1.wav",
]
for i, f in enumerate(files):
print('-------------------------------------------------------')
print('Reading file')
print(' in: %s' % f)
try:
chunks = wavio.read_chunks(f)
except wavio.InvalidRiffWave:
print(" Not a RIFF WAVE!")
continue
s = json.dumps(chunks, indent = 4, separators = (', ', ' : '), sort_keys = True)
for line in s.split('\n'):
print(' %s' % line)
x, sr = wavio.read(f)
if x.ndim > 1:
x = x[:,0]
plt.figure()
plt.plot(x, 'b-')
plt.grid(True)
plt.xlabel('sample bin')
plt.ylabel('amplitude')
plt.title('wav = %s' % f)
# write out forward & reverse
fout = 'fwd-%02d.wav' % i
wavio.write(fout, x, sr, dtype = np.float32)
print('Wrote %s' % fout)
f = fout
chunks = wavio.read_chunks(f)
s = json.dumps(chunks, indent = 4, separators = (', ', ' : '), sort_keys = True)
for line in s.split('\n'):
print(' %s' % line)
x, sr = wavio.read(f)
if x.ndim > 1:
x = x[:,0]
plt.figure()
plt.plot(x, 'b-')
plt.grid(True)
plt.xlabel('sample bin')
plt.ylabel('amplitude')
plt.title('wav = %s' % f)
plt.show()
# -*- coding: utf-8 -*-
"""
Created on Sat Jul 23 15:47:31 2016
@author: SRINIVAS
"""
import numpy as np
import wavio
import sounddevice as sd
fs= 44100
a=0
duration=5
print(0)
recording = sd.rec(duration * fs, samplerate=fs, channels=2)
sd.wait()
print(0)
wavio.write('ine.wav',recording,rate=44100,sampwidth=3)
def save_selected_sound(audiodata,sampleRate,t1,t2,filename):
# t1, t2 in seconds
t1 = math.floor(t1 * sampleRate)
t2 = math.floor(t2 * sampleRate)
wavio.write(str(filename) + '.wav', audiodata[int(t1):int(t2)].astype('int16'), sampleRate, scale='dtype-limits', sampwidth=2)
