# compute interpolated frame
new_grain.norm = frac * t_norms[0] + (1. - frac) * t_norms[1]
new_grain.phas = phas_acc
#print t, step, new_grain.norm
#print t, step, phas_acc
# psola
samples = p.rdo(new_grain)
if t > warmup: # skip the first few frames to warm up phase vocoder
# write to sink
sink_out(samples, hop_s)
# calculate phase advance
dphas = t_phases[1] - t_phases[0] - phi_advance
# unwrap angle to [-pi; pi]
dphas = unwrap2pi(dphas)
# cumulate phase, to be used for next frame
phas_acc += phi_advance + dphas
for t in range(warmup + 1): # purge the last frames from the phase vocoder
new_grain.norm[:] = 0
new_grain.phas[:] = 0
samples = p.rdo(new_grain)
sink_out(samples, read if t == warmup else hop_s)
# just to make sure
#sink_out.close()
format_out = "read {:d} blocks from {:s} at {:d}Hz and rate {:f}, wrote {:d} blocks to {:s}"
print (format_out.format(block_read, source_filename, samplerate, rate,
len(steps), output_filename))
def test_unwrap2pi_takes_array_of_float32(self):
a = arange(-10, 10).astype("float32")
b = unwrap2pi(a)
#print zip(a, b)
assert ( b > -pi ).all()
assert ( b <= pi ).all()
def Stretch(inputfilename, outputfilename, stretchfactor, sample_rate=0):
win_s = 1024
hop_s = win_s // 8 # 87.5 % overlap
warmup = win_s // hop_s - 1
source_filename = inputfilename
output_filename = outputfilename
rate = float(stretchfactor)
samplerate = sample_rate
source_in = source(source_filename, samplerate, hop_s)
samplerate = source_in.samplerate
p = pvoc(win_s, hop_s)
# allocate memory to store norms and phases
n_blocks = source_in.duration // hop_s + 1
# adding an empty frame at end of spectrogram
norms = np.zeros((n_blocks + 1, win_s // 2 + 1), dtype=float_type)
phases = np.zeros((n_blocks + 1, win_s // 2 + 1), dtype=float_type)
block_read = 0
while True:
# read from source
samples, read = source_in()
# compute fftgrain
spec = p(samples)
# store current grain
norms[block_read] = spec.norm
phases[block_read] = spec.phas
# until end of file
if read < hop_s: break
# increment block counter
block_read += 1
# just to make sure
#source_in.close()
sink_out = sink(output_filename, samplerate)
# interpolated time steps (j = alpha * i)
steps = np.arange(0, n_blocks, rate, dtype=float_type)
# initial phase
phas_acc = phases[0]
# excepted phase advance in each bin
phi_advance = np.linspace(0, np.pi * hop_s,
win_s / 2 + 1).astype(float_type)
new_grain = cvec(win_s)
for (t, step) in enumerate(steps):
frac = 1. - np.mod(step, 1.0)
# get pair of frames
t_norms = norms[int(step):int(step + 2)]
t_phases = phases[int(step):int(step + 2)]
# compute interpolated frame
new_grain.norm = frac * t_norms[0] + (1. - frac) * t_norms[1]
new_grain.phas = phas_acc
#print t, step, new_grain.norm
#print t, step, phas_acc
# psola
samples = p.rdo(new_grain)
if t > warmup: # skip the first few frames to warm up phase vocoder
# write to sink
sink_out(samples, hop_s)
# calculate phase advance
dphas = t_phases[1] - t_phases[0] - phi_advance
# unwrap angle to [-pi; pi]
dphas = unwrap2pi(dphas)
# cumulate phase, to be used for next frame
phas_acc += phi_advance + dphas
for t in range(warmup + 1): # purge the last frames from the phase vocoder
new_grain.norm[:] = 0
new_grain.phas[:] = 0
samples = p.rdo(new_grain)
sink_out(samples, read if t == warmup else hop_s)
# just to make sure
#sink_out.close()
format_out = "read {:d} blocks from {:s} at {:d}Hz and rate {:f}, wrote {:d} blocks to {:s}"
print(
format_out.format(block_read, source_filename, samplerate, rate,
len(steps), output_filename))
def test_unwrap2pi_fails_on_list(self):
with self.assertRaises((TypeError, NotImplementedError)):
unwrap2pi(["23.","24.",25.])
def test_unwrap2pi_takes_fvec(self):
a = fvec(10)
b = unwrap2pi(a)
#print zip(a, b)
assert ( b > -pi ).all()
assert ( b <= pi ).all()
def test_unwrap2pi_takes_array_of_float32(self):
a = arange(-10, 10).astype("float32")
b = unwrap2pi(a)
#print zip(a, b)
assert (b > -pi).all()
assert (b <= pi).all()
def test_unwrap2pi(self):
unwrap2pi(int(23))
unwrap2pi(float(23.))
unwrap2pi(int(23.))
unwrap2pi(arange(10))
unwrap2pi(arange(10).astype("int"))
unwrap2pi(arange(10).astype("float"))
unwrap2pi(arange(10).astype("float32"))
unwrap2pi([1,3,5])
unwrap2pi([23.,24.,25.])
a = fvec(10)
a[:] = 4.
unwrap2pi(a)
a = pi/100. * arange(-600,600).astype("float")
unwrap2pi(a)
def test_unwrap2pi(self):
unwrap2pi(int(23))
unwrap2pi(float(23.))
unwrap2pi(long(23.))
unwrap2pi(arange(10))
unwrap2pi(arange(10).astype("int"))
unwrap2pi(arange(10).astype("float"))
unwrap2pi(arange(10).astype("float32"))
unwrap2pi([1, 3, 5])
unwrap2pi([23., 24., 25.])
a = fvec(10)
a[:] = 4.
unwrap2pi(a)
a = pi / 100. * arange(-600, 600).astype("float")
b = unwrap2pi(a)
#print zip(a, b)
try:
print unwrap2pi(["23.", "24.", 25.])
except Exception, e:
pass
def test_unwrap2pi_takes_fvec(self):
a = fvec(10)
b = unwrap2pi(a)
#print zip(a, b)
assert (b > -pi).all()
assert (b <= pi).all()
frac = 1. - np.mod(interp_read, 1.0)
# compute interpolated frame
new_grain.norm = frac * old_grain.norm + (1. - frac) * cur_grain.norm
new_grain.phas = phas_acc
# psola
samples = p.rdo(new_grain)
if interp_read > warmup: # skip the first frames to warm up phase vocoder
# write to sink
sink_out(samples, hop_s)
# calculate phase advance
dphas = cur_grain.phas - old_grain.phas - phi_advance
# unwrap angle to [-pi; pi]
dphas = unwrap2pi(dphas)
# cumulate phase, to be used for next frame
phas_acc += phi_advance + dphas
# prepare for next interp block
interp_block += 1
interp_read = interp_block * rate
if interp_read >= block_read:
break
# copy cur_grain to old_grain
old_grain.norm = np.copy(cur_grain.norm)
old_grain.phas = np.copy(cur_grain.phas)
block_read += 1
if read < hop_s: break
def alter_track_tempo(source_filename,
output_filename,
rate,
sample_rate=0):
win_s = 512
hop_s = win_s // 8 # 87.5 % overlap
warm_up = win_s // hop_s - 1
source_in = source(source_filename, sample_rate, hop_s)
sample_rate = source_in.samplerate
p = pvoc(win_s, hop_s)
sink_out = sink(output_filename, sample_rate)
# excepted phase advance in each bin
phi_advance = np.linspace(0, np.pi * hop_s,
win_s / 2 + 1).astype(float_type)
old_grain = cvec(win_s)
new_grain = cvec(win_s)
block_read = 0
interp_read = 0
interp_block = 0
while True:
samples, read = source_in()
cur_grain = p(samples)
if block_read == 1:
phas_acc = old_grain.phas
# print "block_read", block_read
while True and (block_read > 0):
if interp_read >= block_read:
break
# print "`--- interp_block:", interp_block,
# print 'at orig_block', interp_read, '<- from', block_read - 1, block_read,
# print 'old_grain', old_grain, 'cur_grain', cur_grain
# time to compute interp grain
frac = 1. - np.mod(interp_read, 1.0)
# compute interpolated frame
new_grain.norm = frac * old_grain.norm + (
1. - frac) * cur_grain.norm
new_grain.phas = phas_acc
# psola
samples = p.rdo(new_grain)
if interp_read > warm_up: # skip the first frames to warm up phase vocoder
# write to sink
sink_out(samples, hop_s)
# calculate phase advance
dphas = cur_grain.phas - old_grain.phas - phi_advance
# unwrap angle to [-pi; pi]
dphas = unwrap2pi(dphas)
# cumulate phase, to be used for next frame
phas_acc += phi_advance + dphas
# prepare for next interp block
interp_block += 1
interp_read = interp_block * rate
if interp_read >= block_read:
break
# copy cur_grain to old_grain
old_grain.norm = np.copy(cur_grain.norm)
old_grain.phas = np.copy(cur_grain.phas)
# until end of file
if read < hop_s: break
# increment block counter
block_read += 1
for t in range(warm_up +
2): # purge the last frames from the phase vocoder
new_grain.norm[:] = 0
new_grain.phas[:] = 0
samples = p.rdo(new_grain)
sink_out(samples, read if t == warm_up + 1 else hop_s)
# just to make sure
source_in.close()
sink_out.close()
format_out = "read {:d} blocks from {:s} at {:d}Hz and rate {:f}, wrote {:d} blocks to {:s}"
logging.info(
format_out.format(block_read, source_filename, sample_rate, rate,
interp_block, output_filename))
def test_unwrap2pi(self):
unwrap2pi(int(23))
unwrap2pi(float(23.))
unwrap2pi(int(23.))
unwrap2pi(arange(10))
unwrap2pi(arange(10).astype("int"))
unwrap2pi(arange(10).astype("float"))
unwrap2pi(arange(10).astype("float32"))
unwrap2pi([1,3,5])
unwrap2pi([23.,24.,25.])
a = fvec(10)
a[:] = 4.
unwrap2pi(a)
a = pi/100. * arange(-600,600).astype("float")
b = unwrap2pi (a)
#print zip(a, b)
try:
print(unwrap2pi(["23.","24.",25.]))
except Exception as e:
pass
def _stretch_sound(samples, win_s, hop_s, n):
warmup = win_s // hop_s - 1
p = pvoc(win_s, hop_s)
# allocate memory to store norms and phases
n_blocks = len(samples) // hop_s + 1
# adding an empty frame at end of spectrogram
norms = np.zeros((n_blocks + 1, win_s // 2 + 1), dtype=float_type)
phases = np.zeros((n_blocks + 1, win_s // 2 + 1), dtype=float_type)
block_read = 0
steps_max = len(samples) - (len(samples) % hop_s)
for i in range(0, steps_max, hop_s):
# pitchin = pitch_o(samples[i:i + self._hop_size])
# read from source
samples_proc = np.asarray(samples[i:i + hop_s]).astype(float_type)
# compute fftgrain
spec = p(samples_proc)
# store current grain
norms[block_read] = spec.norm
phases[block_read] = spec.phas
# increment block counter
block_read += 1
# just to make sure
# source_in.close()
sink_out = np.ndarray([], dtype=float_type)
# interpolated time steps (j = alpha * i)
steps = np.arange(0, n_blocks, n, dtype=float_type)
# initial phase
phas_acc = phases[0]
# excepted phase advance in each bin
phi_advance = np.linspace(0, np.pi * hop_s,
win_s / 2 + 1).astype(float_type)
new_grain = cvec(win_s)
for (t, step) in enumerate(steps):
frac = 1. - np.mod(step, 1.0)
# get pair of frames
t_norms = norms[int(step):int(step + 2)]
t_phases = phases[int(step):int(step + 2)]
# compute interpolated frame
new_grain.norm = frac * t_norms[0] + (1. - frac) * t_norms[1]
new_grain.phas = phas_acc
# print t, step, new_grain.norm
# print t, step, phas_acc
# psola
samples_proc = p.rdo(new_grain)
if t > warmup: # skip the first few frames to warm up phase vocoder
# write to sink
sink_out = np.append(sink_out, samples_proc)
# calculate phase advance
dphas = t_phases[1] - t_phases[0] - phi_advance
# unwrap angle to [-pi; pi]
dphas = unwrap2pi(dphas)
# cumulate phase, to be used for next frame
phas_acc += phi_advance + dphas
for t in range(warmup +
1): # purge the last frames from the phase vocoder
new_grain.norm[:] = 0
new_grain.phas[:] = 0
samples_proc = p.rdo(new_grain)
sink_out = np.append(sink_out, samples_proc)
return sink_out
def timestretch(rate, samplerate, duration, win_s, hop_s, n_blocks, norms,
phases, p, block_read, sink_out):
# win_s = 1024
# hop_s = win_s // 8 # 87.5 % overlap
warmup = win_s // hop_s - 1
# # if len(sys.argv) < 3:
# # print("Usage: {:s} <source_filename> <output_filename> <rate> [samplerate]".format(sys.argv[0]))
# # print("""Examples:
# # # twice faster
# # {0} track_01.mp3 track_01_faster.wav 2.0
# # # twice slower
# # {0} track_02.flac track_02_slower.wav 0.5
# # # one and a half time faster, resampling first the input to 22050
# # {0} track_02.flac track_02_slower.wav 1.5 22050""".format(sys.argv[0]))
# # sys.exit(1)
# source_filename = sf
# output_filename = of
# rate = r
# samplerate = 0
# source_in = source(source_filename, samplerate, hop_s)
# samplerate = sr
# p = pvoc(win_s, hop_s)
# # allocate memory to store norms and phases
# n_blocks = dur // hop_s + 1
# # adding an empty frame at end of spectrogram
# norms = np.zeros((n_blocks + 1, win_s // 2 + 1), dtype = float_type)
# phases = np.zeros((n_blocks + 1, win_s // 2 + 1), dtype = float_type)
# block_read = 0
# while True:
# # read from source
# samples, read = source_in()
# # compute fftgrain
# spec = p(samples)
# # store current grain
# norms[block_read] = spec.norm
# phases[block_read] = spec.phas
# # until end of file
# if read < hop_s: break
# # increment block counter
# block_read += 1
# # just to make sure
# #source_in.close()
# sink_out = sink('journey_test.wav', samplerate)
# interpolated time steps (j = alpha * i)
steps = np.arange(0, n_blocks, rate, dtype=float_type)
# initial phase
phas_acc = phases[0]
# excepted phase advance in each bin
phi_advance = np.linspace(0, np.pi * hop_s,
win_s / 2 + 1).astype(float_type)
new_grain = cvec(win_s)
for (t, step) in enumerate(steps):
frac = 1. - np.mod(step, 1.0)
# get pair of frames
t_norms = norms[int(step):int(step + 2)]
t_phases = phases[int(step):int(step + 2)]
# print step
# print t_norms.shape
# print t_phases.shape
# compute interpolated frame
new_grain.norm = frac * t_norms[0] + (1. - frac) * t_norms[1]
new_grain.phas = phas_acc
#print t, step, new_grain.norm
#print t, step, phas_acc
# psola
samples = p.rdo(new_grain)
if t > warmup: # skip the first few frames to warm up phase vocoder
# write to sink
sink_out(samples, hop_s)
# calculate phase advance
dphas = t_phases[1] - t_phases[0] - phi_advance
# unwrap angle to [-pi; pi]
dphas = unwrap2pi(dphas)
# cumulate phase, to be used for next frame
phas_acc += phi_advance + dphas
for t in range(warmup + 1): # purge the last frames from the phase vocoder
new_grain.norm[:] = 0
new_grain.phas[:] = 0
samples = p.rdo(new_grain)
def test_unwrap2pi_fails_on_list(self):
with self.assertRaises((TypeError, NotImplementedError)):
unwrap2pi(["23.", "24.", 25.])
def test_unwrap2pi(self):
unwrap2pi(int(23))
unwrap2pi(float(23.))
unwrap2pi(int(23.))
unwrap2pi(arange(10))
unwrap2pi(arange(10).astype("int"))
unwrap2pi(arange(10).astype("float"))
unwrap2pi(arange(10).astype("float32"))
unwrap2pi([1, 3, 5])
unwrap2pi([23., 24., 25.])
a = fvec(10)
a[:] = 4.
unwrap2pi(a)
a = pi / 100. * arange(-600, 600).astype("float")
unwrap2pi(a)
