Chris@0
|
1 /* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */
|
Chris@0
|
2
|
Chris@0
|
3 /*
|
Chris@0
|
4 Sonic Visualiser
|
Chris@0
|
5 An audio file viewer and annotation editor.
|
Chris@0
|
6 Centre for Digital Music, Queen Mary, University of London.
|
Chris@0
|
7 This file copyright 2006 Chris Cannam.
|
Chris@0
|
8
|
Chris@0
|
9 This program is free software; you can redistribute it and/or
|
Chris@0
|
10 modify it under the terms of the GNU General Public License as
|
Chris@0
|
11 published by the Free Software Foundation; either version 2 of the
|
Chris@0
|
12 License, or (at your option) any later version. See the file
|
Chris@0
|
13 COPYING included with this distribution for more information.
|
Chris@0
|
14 */
|
Chris@0
|
15
|
Chris@14
|
16 #include "PhaseVocoderTimeStretcher.h"
|
Chris@0
|
17
|
Chris@0
|
18 #include <iostream>
|
Chris@0
|
19 #include <cassert>
|
Chris@0
|
20
|
Chris@14
|
21 //#define DEBUG_PHASE_VOCODER_TIME_STRETCHER 1
|
Chris@0
|
22
|
Chris@22
|
23 PhaseVocoderTimeStretcher::PhaseVocoderTimeStretcher(size_t sampleRate,
|
Chris@22
|
24 size_t channels,
|
Chris@16
|
25 float ratio,
|
Chris@16
|
26 bool sharpen,
|
Chris@15
|
27 size_t maxProcessInputBlockSize) :
|
Chris@22
|
28 m_sampleRate(sampleRate),
|
Chris@16
|
29 m_channels(channels),
|
Chris@16
|
30 m_ratio(ratio),
|
Chris@21
|
31 m_sharpen(sharpen),
|
Chris@21
|
32 m_totalCount(0),
|
Chris@21
|
33 m_transientCount(0),
|
Chris@21
|
34 m_n2sum(0)
|
Chris@0
|
35 {
|
Chris@16
|
36 m_wlen = 1024;
|
Chris@16
|
37
|
Chris@21
|
38 //!!! In transient sharpening mode, we need to pick the window
|
Chris@21
|
39 //length so as to be more or less fixed in audio duration (i.e. we
|
Chris@22
|
40 //need to exploit the sample rate)
|
Chris@22
|
41
|
Chris@22
|
42 //!!! have to work out the relationship between wlen and transient
|
Chris@22
|
43 //threshold
|
Chris@21
|
44
|
Chris@15
|
45 if (ratio < 1) {
|
Chris@16
|
46 if (ratio < 0.4) {
|
Chris@16
|
47 m_n1 = 1024;
|
Chris@16
|
48 m_wlen = 2048;
|
Chris@16
|
49 } else if (ratio < 0.8) {
|
Chris@16
|
50 m_n1 = 512;
|
Chris@16
|
51 } else {
|
Chris@16
|
52 m_n1 = 256;
|
Chris@16
|
53 }
|
Chris@16
|
54 if (m_sharpen) {
|
Chris@16
|
55 m_wlen = 2048;
|
Chris@16
|
56 }
|
Chris@15
|
57 m_n2 = m_n1 * ratio;
|
Chris@15
|
58 } else {
|
Chris@16
|
59 if (ratio > 2) {
|
Chris@16
|
60 m_n2 = 512;
|
Chris@16
|
61 m_wlen = 4096;
|
Chris@16
|
62 } else if (ratio > 1.6) {
|
Chris@16
|
63 m_n2 = 384;
|
Chris@16
|
64 m_wlen = 2048;
|
Chris@16
|
65 } else {
|
Chris@16
|
66 m_n2 = 256;
|
Chris@16
|
67 }
|
Chris@16
|
68 if (m_sharpen) {
|
Chris@16
|
69 if (m_wlen < 2048) m_wlen = 2048;
|
Chris@16
|
70 }
|
Chris@15
|
71 m_n1 = m_n2 / ratio;
|
Chris@15
|
72 }
|
Chris@22
|
73
|
Chris@22
|
74 m_transientThreshold = m_wlen / 4.5;
|
Chris@16
|
75
|
Chris@20
|
76 m_analysisWindow = new Window<float>(HanningWindow, m_wlen);
|
Chris@20
|
77 m_synthesisWindow = new Window<float>(HanningWindow, m_wlen);
|
Chris@15
|
78
|
Chris@16
|
79 m_prevPhase = new float *[m_channels];
|
Chris@16
|
80 m_prevAdjustedPhase = new float *[m_channels];
|
Chris@15
|
81
|
Chris@20
|
82 m_prevTransientMag = (float *)fftwf_malloc(sizeof(float) * (m_wlen / 2 + 1));
|
Chris@21
|
83 m_prevTransientScore = 0;
|
Chris@20
|
84 m_prevTransient = false;
|
Chris@20
|
85
|
Chris@20
|
86 m_tempbuf = (float *)fftwf_malloc(sizeof(float) * m_wlen);
|
Chris@20
|
87
|
Chris@20
|
88 m_time = new float *[m_channels];
|
Chris@20
|
89 m_freq = new fftwf_complex *[m_channels];
|
Chris@20
|
90 m_plan = new fftwf_plan[m_channels];
|
Chris@20
|
91 m_iplan = new fftwf_plan[m_channels];
|
Chris@0
|
92
|
Chris@16
|
93 m_inbuf = new RingBuffer<float> *[m_channels];
|
Chris@16
|
94 m_outbuf = new RingBuffer<float> *[m_channels];
|
Chris@16
|
95 m_mashbuf = new float *[m_channels];
|
Chris@16
|
96
|
Chris@16
|
97 m_modulationbuf = (float *)fftwf_malloc(sizeof(float) * m_wlen);
|
Chris@16
|
98
|
Chris@16
|
99 for (size_t c = 0; c < m_channels; ++c) {
|
Chris@16
|
100
|
Chris@20
|
101 m_prevPhase[c] = (float *)fftwf_malloc(sizeof(float) * (m_wlen / 2 + 1));
|
Chris@20
|
102 m_prevAdjustedPhase[c] = (float *)fftwf_malloc(sizeof(float) * (m_wlen / 2 + 1));
|
Chris@16
|
103
|
Chris@20
|
104 m_time[c] = (float *)fftwf_malloc(sizeof(float) * m_wlen);
|
Chris@20
|
105 m_freq[c] = (fftwf_complex *)fftwf_malloc(sizeof(fftwf_complex) *
|
Chris@20
|
106 (m_wlen / 2 + 1));
|
Chris@20
|
107
|
Chris@20
|
108 m_plan[c] = fftwf_plan_dft_r2c_1d(m_wlen, m_time[c], m_freq[c], FFTW_ESTIMATE);
|
Chris@20
|
109 m_iplan[c] = fftwf_plan_dft_c2r_1d(m_wlen, m_freq[c], m_time[c], FFTW_ESTIMATE);
|
Chris@16
|
110
|
Chris@16
|
111 m_inbuf[c] = new RingBuffer<float>(m_wlen);
|
Chris@16
|
112 m_outbuf[c] = new RingBuffer<float>
|
Chris@16
|
113 (lrintf((maxProcessInputBlockSize + m_wlen) * ratio));
|
Chris@16
|
114
|
Chris@16
|
115 m_mashbuf[c] = (float *)fftwf_malloc(sizeof(float) * m_wlen);
|
Chris@16
|
116
|
Chris@16
|
117 for (int i = 0; i < m_wlen; ++i) {
|
Chris@16
|
118 m_mashbuf[c][i] = 0.0;
|
Chris@20
|
119 }
|
Chris@20
|
120
|
Chris@20
|
121 for (int i = 0; i <= m_wlen/2; ++i) {
|
Chris@16
|
122 m_prevPhase[c][i] = 0.0;
|
Chris@16
|
123 m_prevAdjustedPhase[c][i] = 0.0;
|
Chris@16
|
124 }
|
Chris@16
|
125 }
|
Chris@16
|
126
|
Chris@0
|
127 for (int i = 0; i < m_wlen; ++i) {
|
Chris@16
|
128 m_modulationbuf[i] = 0.0;
|
Chris@0
|
129 }
|
Chris@16
|
130
|
Chris@20
|
131 for (int i = 0; i <= m_wlen/2; ++i) {
|
Chris@20
|
132 m_prevTransientMag[i] = 0.0;
|
Chris@20
|
133 }
|
Chris@20
|
134
|
Chris@16
|
135 std::cerr << "PhaseVocoderTimeStretcher: channels = " << channels
|
Chris@16
|
136 << ", ratio = " << ratio
|
Chris@16
|
137 << ", n1 = " << m_n1 << ", n2 = " << m_n2 << ", wlen = "
|
Chris@16
|
138 << m_wlen << ", max = " << maxProcessInputBlockSize
|
Chris@16
|
139 << ", outbuflen = " << m_outbuf[0]->getSize() << std::endl;
|
Chris@0
|
140 }
|
Chris@0
|
141
|
Chris@14
|
142 PhaseVocoderTimeStretcher::~PhaseVocoderTimeStretcher()
|
Chris@0
|
143 {
|
Chris@14
|
144 std::cerr << "PhaseVocoderTimeStretcher::~PhaseVocoderTimeStretcher" << std::endl;
|
Chris@0
|
145
|
Chris@20
|
146 for (size_t c = 0; c < m_channels; ++c) {
|
Chris@0
|
147
|
Chris@20
|
148 fftwf_destroy_plan(m_plan[c]);
|
Chris@20
|
149 fftwf_destroy_plan(m_iplan[c]);
|
Chris@16
|
150
|
Chris@20
|
151 fftwf_free(m_time[c]);
|
Chris@20
|
152 fftwf_free(m_freq[c]);
|
Chris@16
|
153
|
Chris@16
|
154 fftwf_free(m_mashbuf[c]);
|
Chris@16
|
155 fftwf_free(m_prevPhase[c]);
|
Chris@16
|
156 fftwf_free(m_prevAdjustedPhase[c]);
|
Chris@16
|
157
|
Chris@16
|
158 delete m_inbuf[c];
|
Chris@16
|
159 delete m_outbuf[c];
|
Chris@16
|
160 }
|
Chris@16
|
161
|
Chris@20
|
162 fftwf_free(m_tempbuf);
|
Chris@13
|
163 fftwf_free(m_modulationbuf);
|
Chris@20
|
164 fftwf_free(m_prevTransientMag);
|
Chris@0
|
165
|
Chris@16
|
166 delete[] m_prevPhase;
|
Chris@16
|
167 delete[] m_prevAdjustedPhase;
|
Chris@16
|
168 delete[] m_inbuf;
|
Chris@16
|
169 delete[] m_outbuf;
|
Chris@16
|
170 delete[] m_mashbuf;
|
Chris@20
|
171 delete[] m_time;
|
Chris@20
|
172 delete[] m_freq;
|
Chris@20
|
173 delete[] m_plan;
|
Chris@20
|
174 delete[] m_iplan;
|
Chris@15
|
175
|
Chris@20
|
176 delete m_analysisWindow;
|
Chris@20
|
177 delete m_synthesisWindow;
|
Chris@0
|
178 }
|
Chris@0
|
179
|
Chris@0
|
180 size_t
|
Chris@14
|
181 PhaseVocoderTimeStretcher::getProcessingLatency() const
|
Chris@0
|
182 {
|
Chris@0
|
183 return getWindowSize() - getInputIncrement();
|
Chris@0
|
184 }
|
Chris@0
|
185
|
Chris@0
|
186 void
|
Chris@16
|
187 PhaseVocoderTimeStretcher::process(float **input, float **output, size_t samples)
|
Chris@16
|
188 {
|
Chris@16
|
189 putInput(input, samples);
|
Chris@16
|
190 getOutput(output, lrintf(samples * m_ratio));
|
Chris@16
|
191 }
|
Chris@16
|
192
|
Chris@16
|
193 size_t
|
Chris@16
|
194 PhaseVocoderTimeStretcher::getRequiredInputSamples() const
|
Chris@16
|
195 {
|
Chris@16
|
196 if (m_inbuf[0]->getReadSpace() >= m_wlen) return 0;
|
Chris@16
|
197 return m_wlen - m_inbuf[0]->getReadSpace();
|
Chris@16
|
198 }
|
Chris@16
|
199
|
Chris@16
|
200 void
|
Chris@16
|
201 PhaseVocoderTimeStretcher::putInput(float **input, size_t samples)
|
Chris@0
|
202 {
|
Chris@0
|
203 // We need to add samples from input to our internal buffer. When
|
Chris@0
|
204 // we have m_windowSize samples in the buffer, we can process it,
|
Chris@0
|
205 // move the samples back by m_n1 and write the output onto our
|
Chris@0
|
206 // internal output buffer. If we have (samples * ratio) samples
|
Chris@0
|
207 // in that, we can write m_n2 of them back to output and return
|
Chris@0
|
208 // (otherwise we have to write zeroes).
|
Chris@0
|
209
|
Chris@0
|
210 // When we process, we write m_wlen to our fixed output buffer
|
Chris@0
|
211 // (m_mashbuf). We then pull out the first m_n2 samples from that
|
Chris@0
|
212 // buffer, push them into the output ring buffer, and shift
|
Chris@0
|
213 // m_mashbuf left by that amount.
|
Chris@0
|
214
|
Chris@0
|
215 // The processing latency is then m_wlen - m_n2.
|
Chris@0
|
216
|
Chris@0
|
217 size_t consumed = 0;
|
Chris@0
|
218
|
Chris@0
|
219 while (consumed < samples) {
|
Chris@0
|
220
|
Chris@16
|
221 size_t writable = m_inbuf[0]->getWriteSpace();
|
Chris@0
|
222 writable = std::min(writable, samples - consumed);
|
Chris@0
|
223
|
Chris@0
|
224 if (writable == 0) {
|
Chris@0
|
225 //!!! then what? I don't think this should happen, but
|
Chris@16
|
226 std::cerr << "WARNING: PhaseVocoderTimeStretcher::putInput: writable == 0" << std::endl;
|
Chris@0
|
227 break;
|
Chris@0
|
228 }
|
Chris@0
|
229
|
Chris@14
|
230 #ifdef DEBUG_PHASE_VOCODER_TIME_STRETCHER
|
Chris@0
|
231 std::cerr << "writing " << writable << " from index " << consumed << " to inbuf, consumed will be " << consumed + writable << std::endl;
|
Chris@0
|
232 #endif
|
Chris@16
|
233
|
Chris@16
|
234 for (size_t c = 0; c < m_channels; ++c) {
|
Chris@16
|
235 m_inbuf[c]->write(input[c] + consumed, writable);
|
Chris@16
|
236 }
|
Chris@0
|
237 consumed += writable;
|
Chris@0
|
238
|
Chris@16
|
239 while (m_inbuf[0]->getReadSpace() >= m_wlen &&
|
Chris@16
|
240 m_outbuf[0]->getWriteSpace() >= m_n2) {
|
Chris@0
|
241
|
Chris@0
|
242 // We know we have at least m_wlen samples available
|
Chris@16
|
243 // in m_inbuf. We need to peek m_wlen of them for
|
Chris@0
|
244 // processing, and then read m_n1 to advance the read
|
Chris@0
|
245 // pointer.
|
Chris@16
|
246
|
Chris@20
|
247 for (size_t c = 0; c < m_channels; ++c) {
|
Chris@20
|
248
|
Chris@20
|
249 size_t got = m_inbuf[c]->peek(m_tempbuf, m_wlen);
|
Chris@20
|
250 assert(got == m_wlen);
|
Chris@20
|
251
|
Chris@20
|
252 analyseBlock(c, m_tempbuf);
|
Chris@20
|
253 }
|
Chris@20
|
254
|
Chris@20
|
255 bool transient = false;
|
Chris@20
|
256 if (m_sharpen) transient = isTransient();
|
Chris@20
|
257
|
Chris@16
|
258 size_t n2 = m_n2;
|
Chris@20
|
259
|
Chris@20
|
260 if (transient) {
|
Chris@20
|
261 n2 = m_n1;
|
Chris@20
|
262 }
|
Chris@0
|
263
|
Chris@21
|
264 ++m_totalCount;
|
Chris@21
|
265 if (transient) ++m_transientCount;
|
Chris@21
|
266 m_n2sum += n2;
|
Chris@21
|
267
|
Chris@21
|
268 // std::cerr << "ratio for last 10: " <<last10num << "/" << (10 * m_n1) << " = " << float(last10num) / float(10 * m_n1) << " (should be " << m_ratio << ")" << std::endl;
|
Chris@21
|
269
|
Chris@21
|
270 if (m_totalCount > 50 && m_transientCount < m_totalCount) {
|
Chris@21
|
271
|
Chris@21
|
272 int fixed = lrintf(m_transientCount * m_n1);
|
Chris@21
|
273 int squashy = m_n2sum - fixed;
|
Chris@21
|
274
|
Chris@21
|
275 int idealTotal = lrintf(m_totalCount * m_n1 * m_ratio);
|
Chris@21
|
276 int idealSquashy = idealTotal - fixed;
|
Chris@21
|
277
|
Chris@21
|
278 int squashyCount = m_totalCount - m_transientCount;
|
Chris@21
|
279
|
Chris@21
|
280 n2 = lrintf(idealSquashy / squashyCount);
|
Chris@21
|
281
|
Chris@21
|
282 if (n2 != m_n2) {
|
Chris@21
|
283 std::cerr << m_n2 << " -> " << n2 << std::endl;
|
Chris@21
|
284 }
|
Chris@21
|
285 }
|
Chris@21
|
286
|
Chris@16
|
287 for (size_t c = 0; c < m_channels; ++c) {
|
Chris@16
|
288
|
Chris@20
|
289 synthesiseBlock(c, m_mashbuf[c],
|
Chris@20
|
290 c == 0 ? m_modulationbuf : 0,
|
Chris@20
|
291 m_prevTransient ? m_n1 : m_n2);
|
Chris@16
|
292
|
Chris@0
|
293
|
Chris@14
|
294 #ifdef DEBUG_PHASE_VOCODER_TIME_STRETCHER
|
Chris@16
|
295 std::cerr << "writing first " << m_n2 << " from mashbuf, skipping " << m_n1 << " on inbuf " << std::endl;
|
Chris@0
|
296 #endif
|
Chris@16
|
297 m_inbuf[c]->skip(m_n1);
|
Chris@13
|
298
|
Chris@16
|
299 for (size_t i = 0; i < n2; ++i) {
|
Chris@16
|
300 if (m_modulationbuf[i] > 0.f) {
|
Chris@16
|
301 m_mashbuf[c][i] /= m_modulationbuf[i];
|
Chris@16
|
302 }
|
Chris@16
|
303 }
|
Chris@16
|
304
|
Chris@16
|
305 m_outbuf[c]->write(m_mashbuf[c], n2);
|
Chris@16
|
306
|
Chris@16
|
307 for (size_t i = 0; i < m_wlen - n2; ++i) {
|
Chris@16
|
308 m_mashbuf[c][i] = m_mashbuf[c][i + n2];
|
Chris@16
|
309 }
|
Chris@16
|
310
|
Chris@16
|
311 for (size_t i = m_wlen - n2; i < m_wlen; ++i) {
|
Chris@16
|
312 m_mashbuf[c][i] = 0.0f;
|
Chris@13
|
313 }
|
Chris@13
|
314 }
|
Chris@13
|
315
|
Chris@20
|
316 m_prevTransient = transient;
|
Chris@17
|
317
|
Chris@16
|
318 for (size_t i = 0; i < m_wlen - n2; ++i) {
|
Chris@16
|
319 m_modulationbuf[i] = m_modulationbuf[i + n2];
|
Chris@0
|
320 }
|
Chris@13
|
321
|
Chris@16
|
322 for (size_t i = m_wlen - n2; i < m_wlen; ++i) {
|
Chris@13
|
323 m_modulationbuf[i] = 0.0f;
|
Chris@0
|
324 }
|
Chris@21
|
325
|
Chris@21
|
326 if (!transient) m_n2 = n2;
|
Chris@0
|
327 }
|
Chris@0
|
328
|
Chris@0
|
329
|
Chris@14
|
330 #ifdef DEBUG_PHASE_VOCODER_TIME_STRETCHER
|
Chris@16
|
331 std::cerr << "loop ended: inbuf read space " << m_inbuf[0]->getReadSpace() << ", outbuf write space " << m_outbuf[0]->getWriteSpace() << std::endl;
|
Chris@0
|
332 #endif
|
Chris@0
|
333 }
|
Chris@0
|
334
|
Chris@16
|
335 #ifdef DEBUG_PHASE_VOCODER_TIME_STRETCHER
|
Chris@16
|
336 std::cerr << "PhaseVocoderTimeStretcher::putInput returning" << std::endl;
|
Chris@16
|
337 #endif
|
Chris@21
|
338
|
Chris@21
|
339 // std::cerr << "ratio: nominal: " << getRatio() << " actual: "
|
Chris@21
|
340 // << m_total2 << "/" << m_total1 << " = " << float(m_total2) / float(m_total1) << " ideal: " << m_ratio << std::endl;
|
Chris@16
|
341 }
|
Chris@12
|
342
|
Chris@16
|
343 size_t
|
Chris@16
|
344 PhaseVocoderTimeStretcher::getAvailableOutputSamples() const
|
Chris@16
|
345 {
|
Chris@16
|
346 return m_outbuf[0]->getReadSpace();
|
Chris@16
|
347 }
|
Chris@16
|
348
|
Chris@16
|
349 void
|
Chris@16
|
350 PhaseVocoderTimeStretcher::getOutput(float **output, size_t samples)
|
Chris@16
|
351 {
|
Chris@16
|
352 if (m_outbuf[0]->getReadSpace() < samples) {
|
Chris@16
|
353 std::cerr << "WARNING: PhaseVocoderTimeStretcher::getOutput: not enough data (yet?) (" << m_outbuf[0]->getReadSpace() << " < " << samples << ")" << std::endl;
|
Chris@16
|
354 size_t fill = samples - m_outbuf[0]->getReadSpace();
|
Chris@16
|
355 for (size_t c = 0; c < m_channels; ++c) {
|
Chris@16
|
356 for (size_t i = 0; i < fill; ++i) {
|
Chris@16
|
357 output[c][i] = 0.0;
|
Chris@16
|
358 }
|
Chris@16
|
359 m_outbuf[c]->read(output[c] + fill, m_outbuf[c]->getReadSpace());
|
Chris@16
|
360 }
|
Chris@0
|
361 } else {
|
Chris@14
|
362 #ifdef DEBUG_PHASE_VOCODER_TIME_STRETCHER
|
Chris@16
|
363 std::cerr << "enough data - writing " << samples << " from outbuf" << std::endl;
|
Chris@0
|
364 #endif
|
Chris@16
|
365 for (size_t c = 0; c < m_channels; ++c) {
|
Chris@16
|
366 m_outbuf[c]->read(output[c], samples);
|
Chris@16
|
367 }
|
Chris@0
|
368 }
|
Chris@0
|
369
|
Chris@14
|
370 #ifdef DEBUG_PHASE_VOCODER_TIME_STRETCHER
|
Chris@16
|
371 std::cerr << "PhaseVocoderTimeStretcher::getOutput returning" << std::endl;
|
Chris@0
|
372 #endif
|
Chris@0
|
373 }
|
Chris@0
|
374
|
Chris@20
|
375 void
|
Chris@20
|
376 PhaseVocoderTimeStretcher::analyseBlock(size_t c, float *buf)
|
Chris@0
|
377 {
|
Chris@0
|
378 size_t i;
|
Chris@0
|
379
|
Chris@20
|
380 // buf contains m_wlen samples
|
Chris@0
|
381
|
Chris@14
|
382 #ifdef DEBUG_PHASE_VOCODER_TIME_STRETCHER
|
Chris@20
|
383 std::cerr << "PhaseVocoderTimeStretcher::analyseBlock (channel " << c << ")" << std::endl;
|
Chris@0
|
384 #endif
|
Chris@0
|
385
|
Chris@20
|
386 m_analysisWindow->cut(buf);
|
Chris@0
|
387
|
Chris@0
|
388 for (i = 0; i < m_wlen/2; ++i) {
|
Chris@0
|
389 float temp = buf[i];
|
Chris@0
|
390 buf[i] = buf[i + m_wlen/2];
|
Chris@0
|
391 buf[i + m_wlen/2] = temp;
|
Chris@0
|
392 }
|
Chris@19
|
393
|
Chris@0
|
394 for (i = 0; i < m_wlen; ++i) {
|
Chris@20
|
395 m_time[c][i] = buf[i];
|
Chris@0
|
396 }
|
Chris@0
|
397
|
Chris@20
|
398 fftwf_execute(m_plan[c]); // m_time -> m_freq
|
Chris@20
|
399 }
|
Chris@0
|
400
|
Chris@20
|
401 bool
|
Chris@20
|
402 PhaseVocoderTimeStretcher::isTransient()
|
Chris@20
|
403 {
|
Chris@20
|
404 int count = 0;
|
Chris@16
|
405
|
Chris@20
|
406 for (int i = 0; i <= m_wlen/2; ++i) {
|
Chris@16
|
407
|
Chris@20
|
408 float real = 0.f, imag = 0.f;
|
Chris@20
|
409
|
Chris@20
|
410 for (size_t c = 0; c < m_channels; ++c) {
|
Chris@20
|
411 real += m_freq[c][i][0];
|
Chris@20
|
412 imag += m_freq[c][i][1];
|
Chris@16
|
413 }
|
Chris@16
|
414
|
Chris@20
|
415 float sqrmag = (real * real + imag * imag);
|
Chris@20
|
416
|
Chris@20
|
417 if (m_prevTransientMag[i] > 0.f) {
|
Chris@20
|
418 float diff = 10.f * log10f(sqrmag / m_prevTransientMag[i]);
|
Chris@20
|
419 if (diff > 3.f) ++count;
|
Chris@20
|
420 }
|
Chris@20
|
421
|
Chris@20
|
422 m_prevTransientMag[i] = sqrmag;
|
Chris@16
|
423 }
|
Chris@16
|
424
|
Chris@20
|
425 bool isTransient = false;
|
Chris@16
|
426
|
Chris@22
|
427 if (count > m_transientThreshold &&
|
Chris@21
|
428 count > m_prevTransientScore * 1.2) {
|
Chris@20
|
429 isTransient = true;
|
Chris@21
|
430 std::cerr << "isTransient (count = " << count << ", prev = " << m_prevTransientScore << ")" << std::endl;
|
Chris@20
|
431 }
|
Chris@16
|
432
|
Chris@21
|
433 m_prevTransientScore = count;
|
Chris@20
|
434
|
Chris@20
|
435 return isTransient;
|
Chris@20
|
436 }
|
Chris@20
|
437
|
Chris@20
|
438 void
|
Chris@20
|
439 PhaseVocoderTimeStretcher::synthesiseBlock(size_t c,
|
Chris@20
|
440 float *out,
|
Chris@20
|
441 float *modulation,
|
Chris@20
|
442 size_t lastStep)
|
Chris@20
|
443 {
|
Chris@20
|
444 int i;
|
Chris@20
|
445
|
Chris@20
|
446 bool unchanged = (lastStep == m_n1);
|
Chris@20
|
447
|
Chris@20
|
448 for (i = 0; i <= m_wlen/2; ++i) {
|
Chris@0
|
449
|
Chris@20
|
450 float phase = princargf(atan2f(m_freq[c][i][1], m_freq[c][i][0]));
|
Chris@19
|
451 float adjustedPhase = phase;
|
Chris@12
|
452
|
Chris@20
|
453 if (!unchanged) {
|
Chris@16
|
454
|
Chris@20
|
455 float mag = sqrtf(m_freq[c][i][0] * m_freq[c][i][0] +
|
Chris@20
|
456 m_freq[c][i][1] * m_freq[c][i][1]);
|
Chris@19
|
457
|
Chris@20
|
458 float omega = (2 * M_PI * m_n1 * i) / m_wlen;
|
Chris@20
|
459
|
Chris@20
|
460 float expectedPhase = m_prevPhase[c][i] + omega;
|
Chris@20
|
461
|
Chris@20
|
462 float phaseError = princargf(phase - expectedPhase);
|
Chris@20
|
463
|
Chris@20
|
464 float phaseIncrement = (omega + phaseError) / m_n1;
|
Chris@20
|
465
|
Chris@20
|
466 adjustedPhase = m_prevAdjustedPhase[c][i] +
|
Chris@20
|
467 lastStep * phaseIncrement;
|
Chris@20
|
468
|
Chris@20
|
469 float real = mag * cosf(adjustedPhase);
|
Chris@20
|
470 float imag = mag * sinf(adjustedPhase);
|
Chris@20
|
471 m_freq[c][i][0] = real;
|
Chris@20
|
472 m_freq[c][i][1] = imag;
|
Chris@19
|
473 }
|
Chris@19
|
474
|
Chris@16
|
475 m_prevPhase[c][i] = phase;
|
Chris@16
|
476 m_prevAdjustedPhase[c][i] = adjustedPhase;
|
Chris@0
|
477 }
|
Chris@20
|
478
|
Chris@20
|
479 fftwf_execute(m_iplan[c]); // m_freq -> m_time, inverse fft
|
Chris@19
|
480
|
Chris@0
|
481 for (i = 0; i < m_wlen/2; ++i) {
|
Chris@20
|
482 float temp = m_time[c][i];
|
Chris@20
|
483 m_time[c][i] = m_time[c][i + m_wlen/2];
|
Chris@20
|
484 m_time[c][i + m_wlen/2] = temp;
|
Chris@20
|
485 }
|
Chris@20
|
486
|
Chris@20
|
487 for (i = 0; i < m_wlen; ++i) {
|
Chris@20
|
488 m_time[c][i] = m_time[c][i] / m_wlen;
|
Chris@0
|
489 }
|
Chris@15
|
490
|
Chris@20
|
491 m_synthesisWindow->cut(m_time[c]);
|
Chris@19
|
492
|
Chris@19
|
493 for (i = 0; i < m_wlen; ++i) {
|
Chris@20
|
494 out[i] += m_time[c][i];
|
Chris@0
|
495 }
|
Chris@16
|
496
|
Chris@16
|
497 if (modulation) {
|
Chris@16
|
498
|
Chris@20
|
499 float area = m_analysisWindow->getArea();
|
Chris@16
|
500
|
Chris@16
|
501 for (i = 0; i < m_wlen; ++i) {
|
Chris@20
|
502 float val = m_synthesisWindow->getValue(i);
|
Chris@16
|
503 modulation[i] += val * area;
|
Chris@16
|
504 }
|
Chris@16
|
505 }
|
Chris@0
|
506 }
|
Chris@15
|
507
|
Chris@20
|
508
|