-
Notifications
You must be signed in to change notification settings - Fork 0
/
partial_pv.py
117 lines (92 loc) · 3.81 KB
/
partial_pv.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
#! /usr/bin/env python
# Implementation of the timescale algorithm according to Dan Ellis, *A Phase
# Vocoder in Matlab*. http://www.ee.columbia.edu/~dpwe/resources/matlab/pvoc/
# This file follows the implementation modified by Kaitlyn, with analysis in a
# first pass, and synthesis in a second pass.
import sys
from aubio import source, sink, pvoc, cvec
from aubio import unwrap2pi, float_type
import numpy as np
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)
# 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, 'journey.wav', samplerate, rate,
# len(steps), 'journey_test_2.wav'))