def savenoise(samps: np.ndarray, nhours: int, ofn: Path, fs: int, nsec: int,
wavapi: str):
if not ofn:
return
ofn = Path(ofn).expanduser()
f: Any
if wavapi == "raw":
if ofn.is_file(): # delete because we're going to append
ofn.unlink()
with ofn.open("a+b") as f:
for _ in range(int(nhours * 3600 / nsec)):
f.write(samps)
elif wavapi == "scipy": # pragma: no cover
from scipy.io import wavfile
wavfile.write(ofn, fs, samps)
elif wavapi == "skaudio": # pragma: no cover
from scikits.audiolab import Format, Sndfile
fmt = Format("flac")
f = Sndfile(ofn, "w", fmt, 1,
16000) # scikit-audio does not have context manager
f.write_frames(samps)
f.close()
else:
raise ValueError(f"I do not understand write method {wavapi}")
def test_basic_io(self):
""" Check open, close and basic read/write"""
# dirty !
ofilename = join(TEST_DATA_DIR, 'test.wav')
rfd, fd, cfilename = open_tmp_file('pysndfiletest.wav')
try:
nbuff = 22050
# Open the test file for reading
a = Sndfile(ofilename, 'r')
nframes = a.nframes
# Open the copy file for writing
format = Format('wav', 'pcm16')
b = Sndfile(fd, 'w', format, a.channels, a.samplerate)
# Copy the data
for i in range(nframes / nbuff):
tmpa = a.read_frames(nbuff)
assert tmpa.dtype == np.float
b.write_frames(tmpa)
nrem = nframes % nbuff
tmpa = a.read_frames(nrem)
assert tmpa.dtype == np.float
b.write_frames(tmpa)
a.close()
b.close()
finally:
close_tmp_file(rfd, cfilename)
def steg(data1, S1, T1, data2, S2, T2, theta):
d1count = len(data1)
d2count = len(data2)
expectedcount = d1count + d2count
target_split = splitArray(data2, S2, theta)
gap_in_s = int(numpy.floor(T1 * theta / T2))
gap = gap_in_s * S1
i = 0
j = gap
while len(target_split):
data1[j:0] = target_split[0]
# print "####################################################################"
# print "New sample sequence: data1[", j-2, ":", j+len(target_split[0])+2, "] : ", data1[j-2:j+len(target_split[0])+2]
j += gap + len(target_split[0])
target_split.pop(0)
data1[0] = T1 ^ len(data1)
data1[1] = S2 ^ len(data1)
data1[2] = T2 ^ len(data1)
data1[3] = theta
size = len(data1)
# print "\td1: ", d1count, "\n\td2: ", d2count, "\n\tec: ", expectedcount, "\n\tsize: ", size
op = numpy.asarray(data1)
format = Format('wav')
f = Sndfile("stego_file.wav", 'w', format, 1, S1)
f.write_frames(op)
f.close()
return size
def removeFiles(self):
if self.logs:
self.logs.write('removing temp file')
start_time = time.time()
if '.flac' in self.filename: #if flac convert to wav
if not self.removeFile:
if self.logs:
self.logs.write('file was flac: creating wav copy')
try:
format = Format('wav')
f = Sndfile(self.localfilename+".wav", 'w', format, self.channs, self.sample_rate)
f.write_frames(self.original)
f.close()
os.remove(self.localfilename)
self.localfilename = self.localfilename+".wav"
except:
if self.logs :
self.logs.write("Rec.py : error creating wav copy : "+self.localfilename)
return False
if self.removeFile:
if self.logs:
self.logs.write('removing tmeporary file '+self.localfilename)
if os.path.isfile(self.localfilename):
os.remove(self.localfilename)
if self.logs :
self.logs.write("Rec.py : removed temporary file:" + str(time.time() - start_time))
return True
def downsample(fs, sig):
in_file = random_string() + ".wav"
out_file = random_string() + ".wav"
frame_len = fs * WINDOW_SIZE
pad = len(sig) % frame_len
if pad > 0:
sig = np.append(sig, np.zeros(frame_len - pad))
f = Sndfile(in_file, 'w',
Format(type="wav", encoding='pcm16', endianness="file"), 1, fs)
f.write_frames(sig)
f.close()
sox_in = pysox.CSoxStream(in_file)
sox_out = pysox.CSoxStream(out_file,
'w',
pysox.CSignalInfo(SAMPLE_RATE, 1, 8),
fileType='wav')
sox_chain = pysox.CEffectsChain(sox_in, sox_out)
sox_chain.add_effect(pysox.CEffect("rate", [str(SAMPLE_RATE)]))
sox_chain.flow_effects()
sox_out.close()
f = Sndfile(out_file, 'r')
sig = f.read_frames(f.nframes)
f.close()
os.unlink(in_file)
os.unlink(out_file)
return sig
def _test_int_io(self, dt):
# TODO: check if neg or pos value is the highest in abs
rfd, fd, cfilename = open_tmp_file('pysndfiletest.wav')
try:
# Use almost full possible range possible for the given data-type
nb = 2**(8 * np.dtype(dt).itemsize - 3)
fs = 22050
nbuff = fs
a = np.random.random_integers(-nb, nb, nbuff)
a = a.astype(dt)
# Open the file for writing
format = Format('wav', _DTYPE_TO_ENC[dt])
b = Sndfile(fd, 'w', format, 1, fs)
b.write_frames(a)
b.close()
b = Sndfile(cfilename, 'r')
read_a = b.read_frames(nbuff, dtype=dt)
b.close()
assert_array_equal(a, read_a)
finally:
close_tmp_file(rfd, cfilename)
def save_file(device,
sound,
name_append=None,
prefix=(BASE_PATH + "/../recordings/")):
file = Sndfile(
prefix + now_stamp() + ("__" + name_append if name_append else "") +
".wav", 'w', Format('wav', 'pcm16'), device.channels, device.rate)
file.write_frames((1.0 / 32678) * sound)
file.close()
def save_record():
global data
n_channels, fmt = 1, Format('flac', 'pcm16')
caller_id = agi.get_variable("CALLERID(num)")
file_name = 'TmpSpeechFile_' + caller_id + '.flac'
_, temp_sound_file = mkstemp(file_name)
flac_file = Sndfile(temp_sound_file, 'w', fmt, n_channels, SAMPLE_RATE)
flac_file.write_frames(data)
flac_audio = AudioSegment.from_file(temp_sound_file, "flac")
flac_audio.export(PATH + FILE_NAME, format="mp3")
def __init__(self,
fn,
samplerate,
filefmt='wav',
datafmt='pcm16',
channels=1):
fmt = Format(filefmt, datafmt)
self.sf = Sndfile(fn,
mode='w',
format=fmt,
channels=channels,
samplerate=samplerate)
def create_flac_from(sound_samples):
__console.log('prepare flac format for writing to file')
n_channels, fmt = 1, Format('flac', 'pcm16')
caller_id = get_stdn_var(stdin.CALLER_ID)
__console.log('write to temp file')
_, temp_sound_file = mkstemp('TmpSpeechFile_' + caller_id + '.flac')
__console.log('prepare sound file')
flac_file = Sndfile(temp_sound_file, 'w', fmt, n_channels, constants.RAW_RATE)
flac_file.write_frames(np.array(sound_samples))
__console.log('sound file saved')
return temp_sound_file
def writeAudioOutput(output, fs, f, outputTitle):
"""Writes audio output"""
outputTitle = "test.wav"
# Define an output audio format
formt = Format('wav', 'float64')
outFile = Sndfile(outputTitle, 'w', formt, 1, fs)
outFile.write_frames(output)
#Clean Up
f.close()
outFile.close()
return
def __init__(self,
filename,
write=False,
format='wav',
rate=None,
channels=None):
"""
Open audiofile for writing or reading
Parameters
----------
filename : mixed
Input wav file. String if a real file, `sys.stdin` for
standard in.
write: boolean
Set true for writing to a file
rate : int
Sample rate. Only required for writing
channels : int
Number of Channels. Only required for writing
Notes
-----
* The data is assumed to be a numpy array of
floats, normalized between -1 and 1.
"""
try:
from scikits.audiolab import Format, Sndfile
except:
raise RuntimeError('You must have scikits.audiolab installed')
if filename is sys.stdin:
filename = '-'
if write is True and (rate is None or channels is None):
raise ValueError('You must provide sampling rate and '
'number of channels for writing file.')
if write is False:
self.f = Sndfile(filename, 'r')
self.channels = self.f.channels
self.rate = self.f.samplerate
else:
format = Format(format)
self.f = Sndfile(filename, 'w', format, channels, rate)
self.channels = channels
self.rate = rate
def save_wav(sound, action_label, object_label):
wav_path = '/tmp/new_wav'
filename = os.path.join(
wav_path,
action_label + '-' + object_label + '-' + str(time.time()) + '.wav')
format = Format('wav')
print 'writing', filename, '...',
f = Sndfile(filename, 'w', format, 1, 44100)
f.write_frames(sound)
f.close()
print 'DONE'
def main(RAW_DATA_DIR, chunk_length, slide_length):
OUTPUT_DIR=os.path.join(RAW_DATA_DIR, "parts")
if os.path.isdir(OUTPUT_DIR):
answer = raw_input("Parts already exist.\nType y to rebuild from scratch : ")
if answer != 'y':
print("NOT REBUILT !")
sys.exit()
else:
shutil.rmtree(OUTPUT_DIR)
os.makedirs(OUTPUT_DIR)
print RAW_DATA_DIR
print OUTPUT_DIR
chunk_counter = 0
format = Format('wav')
wav_files = glob.glob(RAW_DATA_DIR + '/*.wav')
for filename in wav_files:
wav_file_path = filename
path_no_extension = re.sub(ur'\.wav$', '', filename)
# Read wav and csv files
wave_info = scikits.audiolab.wavread(wav_file_path)
data_wave = wave_info[0]
samplerate = wave_info[1]
len_wave = len(data_wave)
# Cut them in chunk_length seconds chunks.
# Sliding of slide_length seconds
# Zero padding at the end
time_counter = 0
start_index = 0
while(start_index < len_wave):
end_index = (time_counter + chunk_length) * samplerate
if end_index > len_wave:
chunk_wave = np.concatenate((data_wave[start_index:], np.zeros((end_index-len_wave))))
else:
chunk_wave = data_wave[start_index:end_index]
time_counter += slide_length
start_index = time_counter * samplerate
# Write the chunks
outwave_name = OUTPUT_DIR + '/p' + str(chunk_counter) + '.wav'
f = Sndfile(outwave_name, 'w', format, 1, samplerate) # 1 stands for the number of channels
f.write_frames(chunk_wave)
chunk_counter += 1
return
def convert(filename, name):
f = Sndfile(filename, 'r')
fs = f.samplerate
nc = f.channels
enc = f.encoding
data = f.read_frames(f.nframes)
new_name = '/home/bitnami/apps/django/django_projects/Project/sonic_bar_code/static/newfile.wav'
format = Format('wav')
# f = Sndfile(new_name, 'w', format, 1, fs)
f = Sndfile(new_name, 'w', format, nc, fs)
f.write_frames(data)
f.close()
return new_name
def specgram_to_file(path,
mags,
phasifiers,
normalise=True,
specgrammode=None):
if specgrammode == None:
mags = np.exp(mags)
if normalise:
mags -= np.min(mags)
cplx = mags * phasifiers
pcm = istft(cplx.T)
if normalise:
pcm /= np.max(pcm)
outsf = Sndfile(path, "w", Format('wav'), 1, fs)
outsf.write_frames(pcm)
outsf.close()
def export_audio_vidId(fn, samplerate, vid, time, cols):
f = [interp1d(time, cols[:, i]) for i in range(cols.shape[1])]
fmt = Format(type=fn.split('.')[-1])
newfn = '.'.join(
fn.split('.')[:-2] + [fn.split('.')[-2] + ',%d' % vid] +
[fn.split('.')[-1]])
print 'Writing', newfn
wav = Sndfile(newfn, 'w', fmt, cols.shape[1], samplerate)
a = arange(samplerate) / samplerate + time[0]
for i in xrange(int((time[-1] - time[0]))):
y = array([g(a + i) for g in f]).T
wav.write_frames(y)
print '%0.2f%% \r' % (i / (time[-1] - time[0]) * 100),
sys.stdout.flush()
print '100% '
def test_float_frames(self):
""" Check nframes can be a float"""
rfd, fd, cfilename = open_tmp_file('pysndfiletest.wav')
try:
# Open the file for writing
format = Format('wav', 'pcm16')
a = Sndfile(fd, 'rw', format, channels=1, samplerate=22050)
tmp = np.random.random_integers(-100, 100, 1000)
tmp = tmp.astype(np.short)
a.write_frames(tmp)
a.seek(0)
a.sync()
ctmp = a.read_frames(1e2, dtype=np.short)
a.close()
finally:
close_tmp_file(rfd, cfilename)
def test_mismatch(self):
"""Check for bad arguments."""
# This test open a file for writing, but with bad args (channels and
# nframes inverted)
rfd, fd, cfilename = open_tmp_file('pysndfiletest.wav')
try:
# Open the file for writing
format = Format('wav', 'pcm16')
try:
b = Sndfile(fd, 'w', format, channels=22000, samplerate=1)
raise AssertionError("Try to open a file with more than 256 "\
"channels, this should not succeed !")
except ValueError, e:
pass
finally:
close_tmp_file(rfd, cfilename)
def __init__(self, filename, channels=1, samplerate=44100):
"""Set defaults.
Parameters
----------
filename : str
Name of wav file to write to.
channels : int, optional
Number of channels in the wav file.
samplerate : int or float, optional
Sample rate in Hertz.
"""
self._format = Format('wav', encoding='pcm16')
self._filename = filename
self._channels = channels
self._samplerate = samplerate
self._sampwidth = 2
self._fid = None
def __init__(
self,
filename,
samplerate=44100,
channels=1,
format=Format('wav', 'float32'),
):
self._info = {
'filename': filename,
'samplerate': samplerate,
'channels': channels,
'format': format,
'frames': 0,
} # TODO: metadata not implemented
self._sndfile = Sndfile(filename, 'w', format, channels, samplerate)
if not self._sndfile:
raise NameError('Sndfile error loading file %s' % filename)
def _test_read_write(self, dtype):
# dirty !
ofilename = join(TEST_DATA_DIR, 'test.wav')
rfd, fd, cfilename = open_tmp_file('pysndfiletest.wav')
try:
nbuff = 22050
# Open the test file for reading
a = Sndfile(ofilename, 'r')
nframes = a.nframes
# Open the copy file for writing
format = Format('wav', _DTYPE_TO_ENC[dtype])
b = Sndfile(fd, 'w', format, a.channels, a.samplerate)
# Copy the data in the wav file
for i in range(nframes / nbuff):
tmpa = a.read_frames(nbuff, dtype=dtype)
assert tmpa.dtype == dtype
b.write_frames(tmpa)
nrem = nframes % nbuff
tmpa = a.read_frames(nrem)
b.write_frames(tmpa)
a.close()
b.close()
# Now, reopen both files in for reading, and check data are
# the same
a = Sndfile(ofilename, 'r')
b = Sndfile(cfilename, 'r')
for i in range(nframes / nbuff):
tmpa = a.read_frames(nbuff, dtype=dtype)
tmpb = b.read_frames(nbuff, dtype=dtype)
assert_array_equal(tmpa, tmpb)
a.close()
b.close()
finally:
close_tmp_file(rfd, cfilename)
def transform_wav(wav_file, output):
filename = os.path.basename(wav_file)
pathname = os.path.dirname(wav_file)
speaker = os.path.basename(pathname)
dr = os.path.basename(os.path.dirname(pathname))
output_dir = os.path.join(output, dr, speaker)
if not os.path.exists(output_dir):
os.makedirs(output_dir)
output_file = os.path.join(output_dir, filename)
f = Sndfile(wav_file, 'r')
data = f.read_frames(f.nframes)
fs = f.samplerate
nc = f.channels
enc = f.encoding
wav_format = Format('wav')
f_out = Sndfile(output_file, 'w', wav_format, nc, fs)
f_out.write_frames(data)
f.close()
f_out.close()
def audiowrite(data, sr, filename):
"""
Write audio data to a file. Infer type from name.
"""
stem, ext = os.path.splitext(filename)
fmt = ext[1:]
if fmt == "sph":
fmt = "nist"
format = Format(fmt)
if len(np.shape(data)) > 1:
nchans = np.size(data, axis=0)
else:
nchans = 1
f = Sndfile(filename, 'w', format, nchans, sr)
if np.max(np.abs(data)) >= 0.999:
clippos = data >= 0.999
data[clippos] = 0.999
clipneg = data <= -0.999
data[clipneg] = -0.999
print "audiowrite: WARNING: %d samples clipped" % np.sum(
np.r_[clippos, clipneg])
f.write_frames(data)
f.close()
def writeresynthaudio(ch, frames, outpath, hopsize=0.5):
"Actually resynthesises the audio and writes that out"
audiodata = ch.resynth([frame['peaks'] for frame in frames], hopsize)
sf = Sndfile(outpath, "w", Format(), 1, ch.sr)
sf.write_frames(audiodata)
sf.close()
def save_wav(fname, signal, rate):
fp = Sndfile(fname, 'w', Format('wav'), signal.shape[1], rate)
fp.write_frames(signal)
fp.close()
# calculate phase value
phaseVal = np.float(i) / np.float(fs)
# generate tone and set volume for left and right
tone[i][0] = np.sin(2 * np.pi * freq * phaseVal) * amp
tone[i][1] = np.sin(2 * np.pi * (freq * 2) * phaseVal) * amp
#################################################
########## WRITING TONES TO AUDIO FILE ##########
#################################################
# create a name for the new file
new_filename = 'tone.wav'
# Create a Sndfile instance for writing wav files @ 44100 Hz
format = Format('wav')
f = Sndfile(new_filename, 'w', format, 2, fs)
# Write out the samples to the file
f.write_frames(tone)
# close the audio file
f.close()
#################################################
############### PLOT USING PYLAB ################
#################################################
toneL = tone[:, 0]
toneR = tone[:, 1]
def test_raw(self):
rawname = join(TEST_DATA_DIR, 'test.raw')
format = Format('raw', 'pcm16', 'little')
a = Sndfile(rawname, 'r', format, 1, 11025)
assert a.nframes == 11290
a.close()
def decompose(inpath,
outdir='output',
niters=3,
framesize=1024,
hopsize=0.5,
writefiles=True,
wintype='hann'):
"""Given a path to an input file, runs a pursuit iteration to decompose the signal into atoms.
Writes out quite a lot of files - for each iteration, partial resynth, total resynth, residual.
Also returns the aggregated peaks and the residual."""
if not os.path.isfile(inpath):
raise ValueError("path %s not found" % inpath)
sf = Sndfile(inpath, "r")
if sf.channels != 1:
raise Error(
"ERROR in chirpletringmod: sound file has multiple channels (%i) - mono audio required."
% sf.channels)
ch = chirpletringmod.Chirpletringmod(samplerate=sf.samplerate,
framesize=framesize,
wintype=wintype)
signal = sf.read_frames(sf.nframes, dtype=float32)
sf.close()
outnamestem = "%s/%s" % (outdir, os.path.splitext(
os.path.basename(inpath))[0])
resynthtot = zeros(len(signal))
aggpeaks = []
residual = signal
print("chf.decompose: original signal energy %g" % sum(signal**2))
for whichiter in range(niters):
print("----------------------------------------")
print("iteration %i" % whichiter)
iterdata = ch.decompose_oneiter(residual, hopsize=hopsize)
"""Given an input signal, decomposes it a bit like one round of matching-pursuit or suchlike, with the added constraint of
one detection per frame. Returns the peaks found, the resynthesised version, and the residual."""
#return {'peaks':framespeaks, 'resynth':resynth, 'residual':residual}
resynthtot += iterdata['resynth']
aggpeaks.extend(iterdata['peaks'])
if writefiles:
sf = Sndfile("%s_%i_resynth.wav" % (outnamestem, whichiter), "w",
Format(), 1, ch.sr)
sf.write_frames(iterdata['resynth'])
sf.close()
sf = Sndfile("%s_%i_resynthtot.wav" % (outnamestem, whichiter),
"w", Format(), 1, ch.sr)
sf.write_frames(resynthtot)
sf.close()
sf = Sndfile("%s_%i_residual.wav" % (outnamestem, whichiter), "w",
Format(), 1, ch.sr)
sf.write_frames(iterdata['residual'])
sf.close()
residual = iterdata['residual'] # fodder for next iter
print("resynth signal energy %g" % sum(iterdata['resynth']**2))
print("resynthtot signal energy %g" % sum(resynthtot**2))
print("residual signal energy %g" % sum(residual**2))
return {'ch': ch, 'peaks': aggpeaks, 'residual': residual}
def read(self, data):
assert data.shape[1] == self.channels
desired_read_length = data.shape[0]
to_read_length = desired_read_length if self._readed_frames + desired_read_length <= self._info[
'frames'] else self._info['frames'] - self._readed_frames
tmp_data = self._sndfile.read_frames(to_read_length, dtype=data.dtype)
for i in range(len(tmp_data)):
data[i] = tmp_data[i]
self._readed_frames += to_read_length
# print data
return to_read_length
if __name__ == '__main__':
with WaveWriter('lala.ogg', channels=2, format=Format('ogg',
'vorbis')) as w:
# TODO: Metadata is not working!
#w.metadata.title = "La casa perdida"
#w.metadata.artist = "Me"
data = np.zeros((512, 2), np.float32)
for x in xrange(100):
data[:, 0] = (x * np.arange(512, dtype=np.float32) % 512 / 512)
data[512 - x:, 1] = 1
data[:512 - x, 1] = -1
w.write(data)
import sys
import pyaudio
p = pyaudio.PyAudio()
with WaveReader('MamaLadilla-TuBar.ogg', channels=2) as r:
# open stream