def close(self, info):
self.counter[0] *= -1
v = (np.array(self.data) * 32767).astype(np.int16)
with wave.Wave_write('hoge.wav') as wf:
wf.setnchannels(1)
wf.setsampwidth(2)
wf.setframerate(info['framerate'])
wf.writeframes(v.tobytes('C'))
v = (np.array(self.result) * 32767).astype(np.int16)
with wave.Wave_write('result.wav') as wf:
wf.setnchannels(1)
wf.setsampwidth(2)
wf.setframerate(16000)
wf.writeframes(v.tobytes('C'))
def raw_audio2wav(raw_audio: bytes, pyaudio_config: dict) -> bytes or None:
'''
pyaudio_config has the next format:
"pyaudio":{
"format": pyaudio.<format>,
"channels": int,
"rate": int,
"frames_per_buffer": int,
"device": int
},
'''
try:
samp_size = pyaudio.PyAudio().get_sample_size(pyaudio_config['format'])
f = io.BytesIO()
wave_writer = wave.Wave_write(f)
wave_writer.setnchannels(pyaudio_config['channels'])
wave_writer.setsampwidth(samp_size)
wave_writer.setframerate(pyaudio_config['rate'])
wave_writer.writeframes(raw_audio)
f.seek(0)
return f.read()
except Exception as e:
ErrorLogger(__file__, e)
return None
def _wav_write(signal, wav_name, sample_rate):
"""
::
Utility routine for writing wav files, use scikits.audiolab if available
"""
if HAVE_AUDIOLAB:
scikits.audiolab.wavwrite(signal, wav_name, sample_rate)
else:
signal = numpy.atleast_2d(signal)
w = wave.Wave_write(wav_name)
if not w:
print("Error opening file named: ", wav_name)
raise error.BregmanError()
w.setparams(
(signal.shape[0], 2, sample_rate, signal.shape[1], 'NONE', 'NONE'))
b_signal = '' # C-style binary string
for i in range(signal.shape[1]):
# transform to C-style binary string
b_signal += wave.struct.pack('h', int(32767 * signal[0, i]))
if signal.shape[0] > 1:
# transform to C-style binary string
b_signal += wave.struct.pack('h', int(32767 * signal[1, i]))
w.writeframes(b_signal)
w.close()
return True
def data_export(data, file_name):
w = wave.Wave_write(file_name)
w.setnchannels(1)
w.setsampwidth(2)
w.setframerate(44100)
w.writeframes(data)
w.close()
def button4_clicked():
messagebox.showinfo('FileReference Tool', u'作成ファイルは↓↓\n' + f1 + u"と" + f2)
##wav出力
p = (1,2,fs,N,'NONE','not compressed') #16bit= 2byte
fr1 = wave.Wave_write(f2)
fr1.setparams(p)
fr1.writeframes(data1) #byte or bumarray
fr1.close()
fr2 = wave.Wave_write(f1)
fr2.setparams(p)
fr2.writeframes(data2)
fr2.close()
root.quit()
def split(self, audio_data, utterance_dict, speaker, save_path):
"""
Args:
audio_data:
utterance_dict: the dictionary of utterance information of each speaker
key => utterance index
value => [start_frame, end_frame, transcript]
speaker:
save_path: path to save each WAV file
"""
for utt_index, utt_info in sorted(utterance_dict.items(),
key=lambda x: x[0]):
start_frame, end_frame = utt_info[:2]
start_frame = int((start_frame / 100) * self.sampling_rate)
end_frame = int((end_frame / 100) * self.sampling_rate)
audio_data_split = audio_data[start_frame:end_frame]
self.frame_num_dict[speaker + '_' +
utt_index] = audio_data_split.shape[0]
with wave.Wave_write(
join(save_path,
speaker + '_' + str(utt_index) + ".wav")) as w:
w.setnchannels(self.channels)
w.setsampwidth(self.sample_size)
w.setframerate(self.sampling_rate)
w.writeframes(audio_data_split)
def main():
# wf = wave.open("../csv2wav0/バイオリン/output391_3009.wav" , "r" ) #inai.wav byteの文字列で起きさ
# fs = wf.getframerate() # サンプリング周波数
# g = wf.readframes(wf.getnframes()) #getframes(オーディオフレーム：長さ) readframes最大 n 個のオーディオフレームを読み、bytes文字列で返す
#
# print(g[2:4])
# a= g[2:4]
# print(a)
# data = np.frombuffer(a,dtype="int16")
# print(data)
# data = struct.pack("f",data)
# print(data)
name = "../csv2wav0/バイオリン/output391_3009.wav"
wavefile = wave.open(name, "r")
framerate = wavefile.getframerate()
x = wavefile.readframes(wavefile.getnframes())
x = np.frombuffer(x, dtype="int16")
G = np.fft.fft(x)
G1 = np.fft.ifft(G[0:int(len(G) / 2)])
G2 = G1.real
G3 = [c for c in G2]
G4 = np.array(G3, dtype='int16')
w = wave.Wave_write("output.wav")
w.setnchannels(1)
w.setsampwidth(2)
w.setframerate(44100)
w.writeframes(G4)
w.close()
def createwav(data, f0, fs):
print("create")
w = wave.Wave_write("./create{}.wav".format(f0))
p = (1, 2, fs, len(data), "NONE", "not compressed")
w.setparams(p)
w.writeframes(data)
w.close
def _wavwrite(fd, array, framerate):
if array.dtype == np.int16:
sampwidth = 2
elif array.dtype == np.int32:
sampwidth = 4
elif array.dtype == np.float16:
sampwidth = 2
elif array.dtype == np.float16:
sampwidth = 4
else:
raise ValueError('Not Supported dtype {}'.format(array.dtype))
if array.ndim == 2:
nchannels = array.shape[1]
elif array.ndim == 1:
nchannels = 1
else:
raise ValueError('Not Supported dimension: 0 or 1, but got {}'.format(
array.ndim))
w = wave.Wave_write(fd)
w.setnchannels(nchannels)
w.setsampwidth(sampwidth)
w.setframerate(framerate)
w.writeframes(array.tobytes())
w.close()
def save_mch_wave(mix_wavdata,
output_filename,
sample_width=2,
params=None,
framerate=16000):
a_wavdata = mix_wavdata.transpose()
out_wavdata = a_wavdata.copy(order='C')
print "# save data:", output_filename, out_wavdata.shape
ww = wave.Wave_write(output_filename)
if params != None:
ww.setparams(params)
else:
if framerate != None:
ww.setframerate(framerate)
if sample_width != None:
ww.setsampwidth(sample_width)
if len(out_wavdata.shape) <= 1:
ww.setnchannels(1)
else:
ww.setnchannels(out_wavdata.shape[1])
ww.setnframes(out_wavdata.shape[0])
ww.writeframes(
array.array('h',
out_wavdata.astype("int16").ravel()).tostring())
ww.close()
def sin_wave(l):
A = .1
fs = 44100
f0 = 440
f1 = 880
f2 = 1320
t = 10
sin_wave = 0
fname = 'sinwave.wav'
point = np.arange(0, fs * t)
for s in l:
A = 100 - abs(int(float(s[1])))
f = int(float(s[0]))
if A > 0 :
A *= 0.00002
print(A, f)
sin_wave += A * np.sin(2 * np.pi * f * point / fs)
#[print(s) for s in sin_wave]
plt.plot(sin_wave[0:1000])
plt.show()
sin_wave = [int(x * 32767.0) for x in sin_wave] # 16bit符号付き整数に変換
# バイナリ化
binwave = struct.pack("h" * len(sin_wave), *sin_wave)
w = wave.Wave_write(fname)
p = (1, 2, fs, len(binwave), 'NONE', 'not compressed')
w.setparams(p)
w.writeframes(binwave)
w.close()
def noise_detection(ntime):
with open('hoge.wav', 'rb') as f:
data = np.frombuffer(f.read()[44:], dtype='int16').astype(
np.float32) / 32767
start = int(ntime * 48000 / 1024)
end = start + 1024 * 3
noise_data = data[start:end]
noise_data = analyze.resampling(noise_data, 48000, 16000)
n_spec = sp.fft(noise_data * sp.hamming(1024))
n_pow = sp.absolute(n_spec)**2
start = 0
result = []
while True:
end = start + 1024 * 3
if end > len(data):
break
ndata = analyze.resampling(data[start:end], 48000, 16000)
ndata = analyze.spectrum_subtraction(ndata, n_pow)
result.extend(ndata)
start = end
v = (np.array(result) * 32767).astype(np.int16)
with wave.Wave_write('result.wav') as w:
w.setnchannels(1)
w.setsampwidth(2)
w.setframerate(16000)
w.writeframes(v.tobytes('C'))
def __init__(self, length, filename, framerate, channels=1, dtype=int32):
# this was so much simpler to write than ChunkedWavFile
# really wish i learned about memmap before writing it
if isinstance(filename, str):
self.wavfile = open(filename, "wb+")
self._auto_close = True
else:
self.wavfile = filename
self._auto_close = False
wav = wave.Wave_write(None)
wav.close = lambda: None
wav.initfp(self.wavfile)
wav.setparams((channels, dtype_info(dtype).itemsize, framerate, length,
"NONE", "not compressed"))
wav._write_header(length)
del wav
self.wavfile.flush()
self.wav_memmap = mmap.mmap(self.wavfile.fileno(),
length * dtype_info(dtype).itemsize,
access=mmap.ACCESS_WRITE)
self.channels = ndarray((channels, length),
dtype,
self.wav_memmap,
self.wavfile.tell(),
order="F")
self.framerate = framerate
self.filename = filename
def bin2wav(filedata, filename, channels=1, sampwidth=2, framerate=44100, nframe=0, comptype='NONE', compname='not compressed'):
w = wave.Wave_write(filename)
p = (channels, sampwidth, framerate, nframe, comptype, compname)
w.setparams(p)
w.writeframes(filedata)
w.close()
def save_as_wave(self, y, filename):
max_num = 32767.0 / max(y)
bit = [int(x * max_num) for x in y]
waves = struct.pack("h" * len(bit), *bit)
w = wave.Wave_write(filename)
w.setparams((1, 2, SAMPLE_RATE, len(waves), 'NONE', 'not compressed'))
w.writeframes(waves)
w.close()
def split_write(self, count, N):
w = wave.Wave_write("./wav_split/" + self.filename +
"{:04d}.wav".format(count))
w.setnchannels(self.channels)
w.setsampwidth(self.sampwidth)
w.setframerate(self.rframe)
w.writeframes(self.audio_data[count * N:(count + 1) * N])
w.close()
def _write_header(self):
logger.debug('write header')
wave_file = wave.Wave_write(self)
wave_file.setnchannels(CHANNELS)
wave_file.setsampwidth(SAMP_WIDTH)
wave_file.setframerate(RATE)
wave_file.writeframes(b'')
wave_file.close()
def save_wav(filename, data):
data = data.astype(np.int16)
w = wave.Wave_write(filename)
w.setnchannels(1)
w.setsampwidth(2)
w.setframerate(16000)
w.writeframes(data)
w.close()
def output_wav(sound, fs, fileName):
bin_out = struct.pack("h" * len(sound), *sound)
w = wave.Wave_write(fileName)
params = (1, 2, fs, len(bin_out), 'NONE', 'not compressed')
w.setparams(params)
w.writeframes(bin_out)
w.close()
def save_wav(data, path):
w = wave.Wave_write(path)
w.setnchannels(1)
w.setsampwidth(2)
w.setframerate(16000)
w.writeframes(data)
# print("mixed_data")
# print_wave_info(w)
w.close()
def write_wave(idx, data, sr, save_dir): # sr:サンプリング周波数
sin_wave = [int(x * 32767.0) for x in data]
binwave = struct.pack("h" * len(sin_wave), *sin_wave)
wav_file_path = os.path.join(save_dir, str(idx)+'.wav')
w = wave.Wave_write(wav_file_path)
p = (1, 2, sr, len(binwave), 'NONE', 'not compressed')
w.setparams(p)
w.writeframes(binwave)
w.close()
def write_to_file(self, all_datas):
audio_file = io.BytesIO()
wf = wave.Wave_write(audio_file)
wf.setnchannels(1)
wf.setsampwidth(2)
wf.setframerate(16000)
wf.writeframes(b''.join(all_datas))
audio_file.seek(0)
self.input_queue.put(audio_file)
def create_wave(sin_wave, sample_Hz, file_name):
sin_wave = [int(x * 32767.0) for x in sin_wave]
wave_bin = struct.pack("h" * len(sin_wave), *sin_wave)
w = wave.Wave_write(file_name)
p = (1, 2, sample_Hz, len(wave_bin), 'NONE', 'not comperssed')
w.setparams(p)
w.writeframes(wave_bin)
w.close
def addNoise(fileWav, fileVec, noiseVec, outPath, snr=5):
fileGain = np.sqrt(np.mean(np.square(fileVec), axis=-1))
noiseNormed = noiseVec / np.sqrt(np.mean(np.square(noiseVec), axis=-1))
newNoise = noiseGain(snr, sGain=fileGain) * noiseNormed
mixed = fileVec + newNoise
outFile = wave.Wave_write(outPath)
outFile.setparams(fileWav.getparams())
outFile.writeframes(array.array('h', mixed.astype(np.int16)).tobytes())
outFile.close()
def write(self, make_backup=True):
"""
Write the GUANO .WAV file to disk.
:param bool make_backup: create a backup file copy before writing changes or not (default: True);
backups will be saved to a folder named `GUANO_BACKUP`
:raises ValueError: if this `GuanoFile` doesn't represent a valid .WAV by having
appropriate values for `self.wav_params` (see :meth:`wave.Wave_write.setparams()`)
and `self.wav_data` (see :meth:`wave.Wave_write.writeframes()`)
"""
# FIXME: optionally write other unknown subchunks for redundant metadata formats
if not self.filename:
raise ValueError('Cannot write .WAV file without a self.filename!')
if not self.wav_params:
raise ValueError('Cannot write .WAV file without appropriate self.wav_params (see `wavfile.setparams()`)')
if not self.wav_data:
raise ValueError('Cannot write .WAV file without appropriate self.wav_data (see `wavfile.writeframes()`)')
# prepare our metadata for a byte-wise representation
md_bytes = self.serialize()
# create tempfile and write our vanilla .WAV ('data' sub-chunk only)
tempfile = NamedTemporaryFile(mode='w+b', prefix='guano_temp-', suffix='.wav', delete=False)
if os.path.isfile(self.filename):
shutil.copystat(self.filename, tempfile.name)
with closing(wave.Wave_write(tempfile)) as wavfile:
wavfile.setparams(self.wav_params)
wavfile.writeframes(self.wav_data)
# add the 'guan' sub-chunk after the 'data' sub-chunk
tempfile.write(_chunkid.pack(b'guan'))
tempfile.write(_chunksz.pack(len(md_bytes)))
tempfile.write(md_bytes)
# fix the RIFF file length
total_size = tempfile.tell()
tempfile.seek(0x04)
tempfile.write(_chunksz.pack(total_size - 8))
tempfile.close()
# verify it by re-parsing the new version
GuanoFile(tempfile.name)
# finally overwrite the original with our new version (and optionally back up first)
if make_backup and os.path.exists(self.filename):
backup_dir = os.path.join(os.path.dirname(self.filename), 'GUANO_BACKUP')
backup_file = os.path.join(backup_dir, os.path.basename(self.filename))
if not os.path.isdir(backup_dir):
log.debug('Creating backup dir: %s', backup_dir)
os.mkdir(backup_dir)
if os.path.exists(backup_file):
os.remove(backup_file)
os.rename(self.filename, backup_file)
os.rename(tempfile.name, self.filename)
def output_wav(sound, fileName):
sound = [int(x * 32767.0) for x in sound]
bin_out = struct.pack("h" * len(sound), *sound)
w = wave.Wave_write(fileName)
params = (1, 2, 8000, len(bin_out), 'NONE', 'not compressed')
w.setparams(params)
w.writeframes(bin_out)
w.close()
def write_to_file(self, audio):
audio_file = io.BytesIO()
wf = wave.Wave_write(audio_file)
wf.setnchannels(2)
wf.setsampwidth(2)
wf.setframerate(44100)
wf.writeframes(audio)
audio_file.seek(0)
print('inserting in input_queue')
self.input_queue.put(audio_file)
def create_wave(A, f0, fs, t):
point = np.arange(0, fs * t)
sin_wave = A * np.sin(2 * np.pi * f0 * point / fs)
sin_wave = [int(x * 32767.0) for x in sin_wave]
binwave = struct.pack("h" * len(sin_wave), *sin_wave)
w = wave.Wave_write("./doremi/Doremi{}.wav".format(f0))
p = (1, 2, fs, len(binwave), 'NONE', 'not compressed')
w.setparams(p)
w.writeframes(binwave)
w.close()
def save_wave(binwaves):
now = datetime.datetime.now()
fname = "{0}-{1}-{2}-{3}-{4}".format(now.year,now.month,now.day,now.hour,now.minute)
w = wave.Wave_write("{0}.wav".format(fname))
p = (1, 2, 8000, len(binwaves), 'NONE', 'not compressed')
w.setparams(p)
w.writeframes(binwaves)
w.close()
return fname
def saveFile(data, fs, bit, filename, channel=1):
print("channel", channel)
data = [int(v * 32767.0) for v in data]
data = struct.pack("h" * len(data), *data)
w = wave.Wave_write(filename + ".wav")
w.setnchannels(channel)
w.setsampwidth(int(bit/8))
w.setframerate(fs)
w.writeframes(data)
w.close()
