Chris@148
|
1 /* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */
|
Chris@148
|
2
|
Chris@148
|
3 /*
|
Chris@148
|
4 Sonic Visualiser
|
Chris@148
|
5 An audio file viewer and annotation editor.
|
Chris@148
|
6 Centre for Digital Music, Queen Mary, University of London.
|
Chris@148
|
7 This file copyright 2006 Chris Cannam.
|
Chris@148
|
8
|
Chris@148
|
9 This program is free software; you can redistribute it and/or
|
Chris@148
|
10 modify it under the terms of the GNU General Public License as
|
Chris@148
|
11 published by the Free Software Foundation; either version 2 of the
|
Chris@148
|
12 License, or (at your option) any later version. See the file
|
Chris@148
|
13 COPYING included with this distribution for more information.
|
Chris@148
|
14 */
|
Chris@148
|
15
|
Chris@148
|
16 #include "FFTDataServer.h"
|
Chris@148
|
17
|
Chris@148
|
18 #include "FFTFileCache.h"
|
Chris@159
|
19 #include "FFTMemoryCache.h"
|
Chris@148
|
20
|
Chris@148
|
21 #include "model/DenseTimeValueModel.h"
|
Chris@148
|
22
|
Chris@150
|
23 #include "system/System.h"
|
Chris@148
|
24
|
Chris@168
|
25 #include "base/StorageAdviser.h"
|
Chris@183
|
26 #include "base/Profiler.h"
|
Chris@168
|
27
|
Chris@168
|
28
|
Chris@194
|
29 //#define DEBUG_FFT_SERVER 1
|
Chris@194
|
30 //#define DEBUG_FFT_SERVER_FILL 1
|
Chris@148
|
31
|
Chris@148
|
32 #ifdef DEBUG_FFT_SERVER_FILL
|
Chris@153
|
33 #ifndef DEBUG_FFT_SERVER
|
Chris@153
|
34 #define DEBUG_FFT_SERVER 1
|
Chris@153
|
35 #endif
|
Chris@148
|
36 #endif
|
Chris@148
|
37
|
Chris@148
|
38 FFTDataServer::ServerMap FFTDataServer::m_servers;
|
Chris@148
|
39 QMutex FFTDataServer::m_serverMapMutex;
|
Chris@148
|
40
|
Chris@148
|
41 FFTDataServer *
|
Chris@148
|
42 FFTDataServer::getInstance(const DenseTimeValueModel *model,
|
Chris@148
|
43 int channel,
|
Chris@148
|
44 WindowType windowType,
|
Chris@148
|
45 size_t windowSize,
|
Chris@148
|
46 size_t windowIncrement,
|
Chris@148
|
47 size_t fftSize,
|
Chris@148
|
48 bool polar,
|
Chris@148
|
49 size_t fillFromColumn)
|
Chris@148
|
50 {
|
Chris@148
|
51 QString n = generateFileBasename(model,
|
Chris@148
|
52 channel,
|
Chris@148
|
53 windowType,
|
Chris@148
|
54 windowSize,
|
Chris@148
|
55 windowIncrement,
|
Chris@148
|
56 fftSize,
|
Chris@148
|
57 polar);
|
Chris@148
|
58
|
Chris@148
|
59 FFTDataServer *server = 0;
|
Chris@148
|
60
|
Chris@148
|
61 QMutexLocker locker(&m_serverMapMutex);
|
Chris@148
|
62
|
Chris@148
|
63 if ((server = findServer(n))) {
|
Chris@148
|
64 return server;
|
Chris@148
|
65 }
|
Chris@148
|
66
|
Chris@148
|
67 QString npn = generateFileBasename(model,
|
Chris@148
|
68 channel,
|
Chris@148
|
69 windowType,
|
Chris@148
|
70 windowSize,
|
Chris@148
|
71 windowIncrement,
|
Chris@148
|
72 fftSize,
|
Chris@148
|
73 !polar);
|
Chris@148
|
74
|
Chris@148
|
75 if ((server = findServer(npn))) {
|
Chris@148
|
76 return server;
|
Chris@148
|
77 }
|
Chris@148
|
78
|
Chris@148
|
79 m_servers[n] = ServerCountPair
|
Chris@148
|
80 (new FFTDataServer(n,
|
Chris@148
|
81 model,
|
Chris@148
|
82 channel,
|
Chris@148
|
83 windowType,
|
Chris@148
|
84 windowSize,
|
Chris@148
|
85 windowIncrement,
|
Chris@148
|
86 fftSize,
|
Chris@148
|
87 polar,
|
Chris@148
|
88 fillFromColumn),
|
Chris@148
|
89 1);
|
Chris@148
|
90
|
Chris@148
|
91 return m_servers[n].first;
|
Chris@148
|
92 }
|
Chris@148
|
93
|
Chris@148
|
94 FFTDataServer *
|
Chris@148
|
95 FFTDataServer::getFuzzyInstance(const DenseTimeValueModel *model,
|
Chris@148
|
96 int channel,
|
Chris@148
|
97 WindowType windowType,
|
Chris@148
|
98 size_t windowSize,
|
Chris@148
|
99 size_t windowIncrement,
|
Chris@148
|
100 size_t fftSize,
|
Chris@148
|
101 bool polar,
|
Chris@148
|
102 size_t fillFromColumn)
|
Chris@148
|
103 {
|
Chris@148
|
104 // Fuzzy matching:
|
Chris@148
|
105 //
|
Chris@148
|
106 // -- if we're asked for polar and have non-polar, use it (and
|
Chris@148
|
107 // vice versa). This one is vital, and we do it for non-fuzzy as
|
Chris@148
|
108 // well (above).
|
Chris@148
|
109 //
|
Chris@148
|
110 // -- if we're asked for an instance with a given fft size and we
|
Chris@148
|
111 // have one already with a multiple of that fft size but the same
|
Chris@148
|
112 // window size and type (and model), we can draw the results from
|
Chris@148
|
113 // it (e.g. the 1st, 2nd, 3rd etc bins of a 512-sample FFT are the
|
Chris@148
|
114 // same as the the 1st, 5th, 9th etc of a 2048-sample FFT of the
|
Chris@148
|
115 // same window plus zero padding).
|
Chris@148
|
116 //
|
Chris@148
|
117 // -- if we're asked for an instance with a given window type and
|
Chris@148
|
118 // size and fft size and we have one already the same but with a
|
Chris@148
|
119 // smaller increment, we can draw the results from it (provided
|
Chris@148
|
120 // our increment is a multiple of its)
|
Chris@148
|
121 //
|
Chris@152
|
122 // The FFTModel knows how to interpret these things. In
|
Chris@148
|
123 // both cases we require that the larger one is a power-of-two
|
Chris@148
|
124 // multiple of the smaller (e.g. even though in principle you can
|
Chris@148
|
125 // draw the results at increment 256 from those at increment 768
|
Chris@152
|
126 // or 1536, the model doesn't support this).
|
Chris@148
|
127
|
Chris@148
|
128 {
|
Chris@148
|
129 QMutexLocker locker(&m_serverMapMutex);
|
Chris@148
|
130
|
Chris@148
|
131 ServerMap::iterator best = m_servers.end();
|
Chris@148
|
132 int bestdist = -1;
|
Chris@148
|
133
|
Chris@148
|
134 for (ServerMap::iterator i = m_servers.begin(); i != m_servers.end(); ++i) {
|
Chris@148
|
135
|
Chris@148
|
136 FFTDataServer *server = i->second.first;
|
Chris@148
|
137
|
Chris@148
|
138 if (server->getModel() == model &&
|
Chris@148
|
139 (server->getChannel() == channel || model->getChannelCount() == 1) &&
|
Chris@148
|
140 server->getWindowType() == windowType &&
|
Chris@148
|
141 server->getWindowSize() == windowSize &&
|
Chris@148
|
142 server->getWindowIncrement() <= windowIncrement &&
|
Chris@148
|
143 server->getFFTSize() >= fftSize) {
|
Chris@148
|
144
|
Chris@148
|
145 if ((windowIncrement % server->getWindowIncrement()) != 0) continue;
|
Chris@148
|
146 int ratio = windowIncrement / server->getWindowIncrement();
|
Chris@148
|
147 bool poweroftwo = true;
|
Chris@148
|
148 while (ratio > 1) {
|
Chris@148
|
149 if (ratio & 0x1) {
|
Chris@148
|
150 poweroftwo = false;
|
Chris@148
|
151 break;
|
Chris@148
|
152 }
|
Chris@148
|
153 ratio >>= 1;
|
Chris@148
|
154 }
|
Chris@148
|
155 if (!poweroftwo) continue;
|
Chris@148
|
156
|
Chris@148
|
157 if ((server->getFFTSize() % fftSize) != 0) continue;
|
Chris@148
|
158 ratio = server->getFFTSize() / fftSize;
|
Chris@148
|
159 while (ratio > 1) {
|
Chris@148
|
160 if (ratio & 0x1) {
|
Chris@148
|
161 poweroftwo = false;
|
Chris@148
|
162 break;
|
Chris@148
|
163 }
|
Chris@148
|
164 ratio >>= 1;
|
Chris@148
|
165 }
|
Chris@148
|
166 if (!poweroftwo) continue;
|
Chris@148
|
167
|
Chris@148
|
168 int distance = 0;
|
Chris@148
|
169
|
Chris@148
|
170 if (server->getPolar() != polar) distance += 1;
|
Chris@148
|
171
|
Chris@148
|
172 distance += ((windowIncrement / server->getWindowIncrement()) - 1) * 15;
|
Chris@148
|
173 distance += ((server->getFFTSize() / fftSize) - 1) * 10;
|
Chris@148
|
174
|
Chris@148
|
175 if (server->getFillCompletion() < 50) distance += 100;
|
Chris@148
|
176
|
Chris@148
|
177 #ifdef DEBUG_FFT_SERVER
|
Chris@148
|
178 std::cerr << "Distance " << distance << ", best is " << bestdist << std::endl;
|
Chris@148
|
179 #endif
|
Chris@148
|
180
|
Chris@148
|
181 if (bestdist == -1 || distance < bestdist) {
|
Chris@148
|
182 bestdist = distance;
|
Chris@148
|
183 best = i;
|
Chris@148
|
184 }
|
Chris@148
|
185 }
|
Chris@148
|
186 }
|
Chris@148
|
187
|
Chris@148
|
188 if (bestdist >= 0) {
|
Chris@148
|
189 ++best->second.second;
|
Chris@148
|
190 return best->second.first;
|
Chris@148
|
191 }
|
Chris@148
|
192 }
|
Chris@148
|
193
|
Chris@148
|
194 // Nothing found, make a new one
|
Chris@148
|
195
|
Chris@148
|
196 return getInstance(model,
|
Chris@148
|
197 channel,
|
Chris@148
|
198 windowType,
|
Chris@148
|
199 windowSize,
|
Chris@148
|
200 windowIncrement,
|
Chris@148
|
201 fftSize,
|
Chris@148
|
202 polar,
|
Chris@148
|
203 fillFromColumn);
|
Chris@148
|
204 }
|
Chris@148
|
205
|
Chris@148
|
206 FFTDataServer *
|
Chris@148
|
207 FFTDataServer::findServer(QString n)
|
Chris@148
|
208 {
|
Chris@148
|
209 if (m_servers.find(n) != m_servers.end()) {
|
Chris@148
|
210 ++m_servers[n].second;
|
Chris@148
|
211 return m_servers[n].first;
|
Chris@148
|
212 }
|
Chris@148
|
213
|
Chris@148
|
214 return 0;
|
Chris@148
|
215 }
|
Chris@148
|
216
|
Chris@148
|
217 void
|
Chris@152
|
218 FFTDataServer::claimInstance(FFTDataServer *server)
|
Chris@152
|
219 {
|
Chris@152
|
220
|
Chris@152
|
221 QMutexLocker locker(&m_serverMapMutex);
|
Chris@152
|
222
|
Chris@152
|
223 for (ServerMap::iterator i = m_servers.begin(); i != m_servers.end(); ++i) {
|
Chris@152
|
224 if (i->second.first == server) {
|
Chris@152
|
225 ++i->second.second;
|
Chris@152
|
226 return;
|
Chris@152
|
227 }
|
Chris@152
|
228 }
|
Chris@152
|
229
|
Chris@152
|
230 std::cerr << "ERROR: FFTDataServer::claimInstance: instance "
|
Chris@152
|
231 << server << " unknown!" << std::endl;
|
Chris@152
|
232 }
|
Chris@152
|
233
|
Chris@152
|
234 void
|
Chris@148
|
235 FFTDataServer::releaseInstance(FFTDataServer *server)
|
Chris@148
|
236 {
|
Chris@148
|
237 #ifdef DEBUG_FFT_SERVER
|
Chris@148
|
238 std::cerr << "FFTDataServer::releaseInstance(" << server << ")" << std::endl;
|
Chris@148
|
239 #endif
|
Chris@148
|
240
|
Chris@148
|
241 QMutexLocker locker(&m_serverMapMutex);
|
Chris@148
|
242
|
Chris@148
|
243 //!!! not a good strategy. Want something like:
|
Chris@148
|
244
|
Chris@148
|
245 // -- if ref count > 0, decrement and return
|
Chris@148
|
246 // -- if the instance hasn't been used at all, delete it immediately
|
Chris@148
|
247 // -- if fewer than N instances (N = e.g. 3) remain with zero refcounts,
|
Chris@148
|
248 // leave them hanging around
|
Chris@148
|
249 // -- if N instances with zero refcounts remain, delete the one that
|
Chris@148
|
250 // was last released first
|
Chris@148
|
251 // -- if we run out of disk space when allocating an instance, go back
|
Chris@148
|
252 // and delete the spare N instances before trying again
|
Chris@148
|
253 // -- have an additional method to indicate that a model has been
|
Chris@148
|
254 // destroyed, so that we can delete all of its fft server instances
|
Chris@148
|
255
|
Chris@148
|
256 // also:
|
Chris@148
|
257 //
|
Chris@148
|
258
|
Chris@148
|
259 for (ServerMap::iterator i = m_servers.begin(); i != m_servers.end(); ++i) {
|
Chris@148
|
260 if (i->second.first == server) {
|
Chris@148
|
261 if (i->second.second == 0) {
|
Chris@148
|
262 std::cerr << "ERROR: FFTDataServer::releaseInstance("
|
Chris@148
|
263 << server << "): instance not allocated" << std::endl;
|
Chris@148
|
264 } else if (--i->second.second == 0) {
|
Chris@148
|
265 if (server->m_lastUsedCache == -1) { // never used
|
Chris@148
|
266 delete server;
|
Chris@148
|
267 m_servers.erase(i);
|
Chris@148
|
268 } else {
|
Chris@148
|
269 server->suspend();
|
Chris@148
|
270 purgeLimbo();
|
Chris@148
|
271 }
|
Chris@148
|
272 }
|
Chris@148
|
273 return;
|
Chris@148
|
274 }
|
Chris@148
|
275 }
|
Chris@148
|
276
|
Chris@148
|
277 std::cerr << "ERROR: FFTDataServer::releaseInstance(" << server << "): "
|
Chris@148
|
278 << "instance not found" << std::endl;
|
Chris@148
|
279 }
|
Chris@148
|
280
|
Chris@148
|
281 void
|
Chris@148
|
282 FFTDataServer::purgeLimbo(int maxSize)
|
Chris@148
|
283 {
|
Chris@148
|
284 ServerMap::iterator i = m_servers.end();
|
Chris@148
|
285
|
Chris@148
|
286 int count = 0;
|
Chris@148
|
287
|
Chris@148
|
288 while (i != m_servers.begin()) {
|
Chris@148
|
289 --i;
|
Chris@148
|
290 if (i->second.second == 0) {
|
Chris@148
|
291 if (++count > maxSize) {
|
Chris@148
|
292 delete i->second.first;
|
Chris@148
|
293 m_servers.erase(i);
|
Chris@148
|
294 return;
|
Chris@148
|
295 }
|
Chris@148
|
296 }
|
Chris@148
|
297 }
|
Chris@148
|
298 }
|
Chris@148
|
299
|
Chris@148
|
300 FFTDataServer::FFTDataServer(QString fileBaseName,
|
Chris@148
|
301 const DenseTimeValueModel *model,
|
Chris@148
|
302 int channel,
|
Chris@148
|
303 WindowType windowType,
|
Chris@148
|
304 size_t windowSize,
|
Chris@148
|
305 size_t windowIncrement,
|
Chris@148
|
306 size_t fftSize,
|
Chris@148
|
307 bool polar,
|
Chris@148
|
308 size_t fillFromColumn) :
|
Chris@148
|
309 m_fileBaseName(fileBaseName),
|
Chris@148
|
310 m_model(model),
|
Chris@148
|
311 m_channel(channel),
|
Chris@148
|
312 m_windower(windowType, windowSize),
|
Chris@148
|
313 m_windowSize(windowSize),
|
Chris@148
|
314 m_windowIncrement(windowIncrement),
|
Chris@148
|
315 m_fftSize(fftSize),
|
Chris@148
|
316 m_polar(polar),
|
Chris@183
|
317 m_width(0),
|
Chris@183
|
318 m_height(0),
|
Chris@183
|
319 m_cacheWidth(0),
|
Chris@172
|
320 m_memoryCache(false),
|
Chris@172
|
321 m_compactCache(false),
|
Chris@148
|
322 m_lastUsedCache(-1),
|
Chris@148
|
323 m_fftInput(0),
|
Chris@148
|
324 m_exiting(false),
|
Chris@153
|
325 m_suspended(true), //!!! or false?
|
Chris@148
|
326 m_fillThread(0)
|
Chris@148
|
327 {
|
Chris@193
|
328 #ifdef DEBUG_FFT_SERVER
|
Chris@193
|
329 std::cerr << "FFTDataServer(" << this << " [" << (void *)QThread::currentThreadId() << "])::FFTDataServer" << std::endl;
|
Chris@193
|
330 #endif
|
Chris@193
|
331
|
Chris@148
|
332 size_t start = m_model->getStartFrame();
|
Chris@148
|
333 size_t end = m_model->getEndFrame();
|
Chris@148
|
334
|
Chris@148
|
335 m_width = (end - start) / m_windowIncrement + 1;
|
Chris@148
|
336 m_height = m_fftSize / 2;
|
Chris@148
|
337
|
Chris@148
|
338 size_t maxCacheSize = 20 * 1024 * 1024;
|
Chris@148
|
339 size_t columnSize = m_height * sizeof(fftsample) * 2 + sizeof(fftsample);
|
Chris@148
|
340 if (m_width * columnSize < maxCacheSize * 2) m_cacheWidth = m_width;
|
Chris@148
|
341 else m_cacheWidth = maxCacheSize / columnSize;
|
Chris@148
|
342
|
Chris@148
|
343 int bits = 0;
|
Chris@148
|
344 while (m_cacheWidth) { m_cacheWidth >>= 1; ++bits; }
|
Chris@148
|
345 m_cacheWidth = 2;
|
Chris@148
|
346 while (bits) { m_cacheWidth <<= 1; --bits; }
|
Chris@172
|
347
|
Chris@172
|
348 //!!! Need to pass in what this server is intended for
|
Chris@172
|
349 // (e.g. playback processing, spectrogram, feature extraction),
|
Chris@172
|
350 // or pass in something akin to the storage adviser criteria.
|
Chris@172
|
351 // That probably goes alongside the polar argument.
|
Chris@172
|
352 // For now we'll assume "spectrogram" criteria for polar ffts,
|
Chris@172
|
353 // and "feature extraction" criteria for rectangular ones.
|
Chris@172
|
354
|
Chris@172
|
355 StorageAdviser::Criteria criteria;
|
Chris@172
|
356 if (m_polar) {
|
Chris@172
|
357 criteria = StorageAdviser::Criteria
|
Chris@172
|
358 (StorageAdviser::SpeedCritical | StorageAdviser::LongRetentionLikely);
|
Chris@172
|
359 } else {
|
Chris@172
|
360 criteria = StorageAdviser::Criteria(StorageAdviser::PrecisionCritical);
|
Chris@172
|
361 }
|
Chris@172
|
362
|
Chris@172
|
363 int cells = m_width * m_height;
|
Chris@172
|
364 int minimumSize = (cells / 1024) * sizeof(uint16_t); // kb
|
Chris@172
|
365 int maximumSize = (cells / 1024) * sizeof(float); // kb
|
Chris@172
|
366
|
Chris@172
|
367 //!!! catch InsufficientDiscSpace
|
Chris@172
|
368
|
Chris@172
|
369 StorageAdviser::Recommendation recommendation =
|
Chris@172
|
370 StorageAdviser::recommend(criteria, minimumSize, maximumSize);
|
Chris@172
|
371
|
Chris@172
|
372 std::cerr << "Recommendation was: " << recommendation << std::endl;
|
Chris@172
|
373
|
Chris@172
|
374 m_memoryCache = ((recommendation & StorageAdviser::UseMemory) ||
|
Chris@172
|
375 (recommendation & StorageAdviser::PreferMemory));
|
Chris@172
|
376
|
Chris@172
|
377 m_compactCache = (recommendation & StorageAdviser::ConserveSpace);
|
Chris@148
|
378
|
Chris@148
|
379 #ifdef DEBUG_FFT_SERVER
|
Chris@148
|
380 std::cerr << "Width " << m_width << ", cache width " << m_cacheWidth << " (size " << m_cacheWidth * columnSize << ")" << std::endl;
|
Chris@148
|
381 #endif
|
Chris@148
|
382
|
Chris@148
|
383 for (size_t i = 0; i <= m_width / m_cacheWidth; ++i) {
|
Chris@148
|
384 m_caches.push_back(0);
|
Chris@148
|
385 }
|
Chris@148
|
386
|
Chris@148
|
387 m_fftInput = (fftsample *)
|
Chris@148
|
388 fftwf_malloc(fftSize * sizeof(fftsample));
|
Chris@148
|
389
|
Chris@148
|
390 m_fftOutput = (fftwf_complex *)
|
Chris@148
|
391 fftwf_malloc(fftSize * sizeof(fftwf_complex));
|
Chris@148
|
392
|
Chris@148
|
393 m_workbuffer = (float *)
|
Chris@148
|
394 fftwf_malloc(fftSize * sizeof(float));
|
Chris@148
|
395
|
Chris@148
|
396 m_fftPlan = fftwf_plan_dft_r2c_1d(m_fftSize,
|
Chris@148
|
397 m_fftInput,
|
Chris@148
|
398 m_fftOutput,
|
Chris@148
|
399 FFTW_ESTIMATE);
|
Chris@148
|
400
|
Chris@148
|
401 if (!m_fftPlan) {
|
Chris@148
|
402 std::cerr << "ERROR: fftwf_plan_dft_r2c_1d(" << m_windowSize << ") failed!" << std::endl;
|
Chris@148
|
403 throw(0);
|
Chris@148
|
404 }
|
Chris@148
|
405
|
Chris@148
|
406 m_fillThread = new FillThread(*this, fillFromColumn);
|
Chris@148
|
407 }
|
Chris@148
|
408
|
Chris@148
|
409 FFTDataServer::~FFTDataServer()
|
Chris@148
|
410 {
|
Chris@148
|
411 #ifdef DEBUG_FFT_SERVER
|
Chris@193
|
412 std::cerr << "FFTDataServer(" << this << " [" << (void *)QThread::currentThreadId() << "])::~FFTDataServer()" << std::endl;
|
Chris@148
|
413 #endif
|
Chris@148
|
414
|
Chris@155
|
415 m_suspended = false;
|
Chris@148
|
416 m_exiting = true;
|
Chris@148
|
417 m_condition.wakeAll();
|
Chris@148
|
418 if (m_fillThread) {
|
Chris@148
|
419 m_fillThread->wait();
|
Chris@148
|
420 delete m_fillThread;
|
Chris@148
|
421 }
|
Chris@148
|
422
|
Chris@148
|
423 QMutexLocker locker(&m_writeMutex);
|
Chris@148
|
424
|
Chris@148
|
425 for (CacheVector::iterator i = m_caches.begin(); i != m_caches.end(); ++i) {
|
Chris@148
|
426 delete *i;
|
Chris@148
|
427 }
|
Chris@148
|
428
|
Chris@148
|
429 deleteProcessingData();
|
Chris@148
|
430 }
|
Chris@148
|
431
|
Chris@148
|
432 void
|
Chris@148
|
433 FFTDataServer::deleteProcessingData()
|
Chris@148
|
434 {
|
Chris@193
|
435 #ifdef DEBUG_FFT_SERVER
|
Chris@193
|
436 std::cerr << "FFTDataServer(" << this << " [" << (void *)QThread::currentThreadId() << "]): deleteProcessingData" << std::endl;
|
Chris@193
|
437 #endif
|
Chris@148
|
438 if (m_fftInput) {
|
Chris@148
|
439 fftwf_destroy_plan(m_fftPlan);
|
Chris@148
|
440 fftwf_free(m_fftInput);
|
Chris@148
|
441 fftwf_free(m_fftOutput);
|
Chris@148
|
442 fftwf_free(m_workbuffer);
|
Chris@148
|
443 }
|
Chris@148
|
444 m_fftInput = 0;
|
Chris@148
|
445 }
|
Chris@148
|
446
|
Chris@148
|
447 void
|
Chris@148
|
448 FFTDataServer::suspend()
|
Chris@148
|
449 {
|
Chris@148
|
450 #ifdef DEBUG_FFT_SERVER
|
Chris@193
|
451 std::cerr << "FFTDataServer(" << this << " [" << (void *)QThread::currentThreadId() << "]): suspend" << std::endl;
|
Chris@148
|
452 #endif
|
Chris@183
|
453 Profiler profiler("FFTDataServer::suspend", false);
|
Chris@183
|
454
|
Chris@148
|
455 QMutexLocker locker(&m_writeMutex);
|
Chris@148
|
456 m_suspended = true;
|
Chris@148
|
457 for (CacheVector::iterator i = m_caches.begin(); i != m_caches.end(); ++i) {
|
Chris@148
|
458 if (*i) (*i)->suspend();
|
Chris@148
|
459 }
|
Chris@148
|
460 }
|
Chris@148
|
461
|
Chris@148
|
462 void
|
Chris@155
|
463 FFTDataServer::suspendWrites()
|
Chris@155
|
464 {
|
Chris@155
|
465 #ifdef DEBUG_FFT_SERVER
|
Chris@193
|
466 std::cerr << "FFTDataServer(" << this << " [" << (void *)QThread::currentThreadId() << "]): suspendWrites" << std::endl;
|
Chris@155
|
467 #endif
|
Chris@183
|
468 Profiler profiler("FFTDataServer::suspendWrites", false);
|
Chris@183
|
469
|
Chris@155
|
470 m_suspended = true;
|
Chris@155
|
471 }
|
Chris@155
|
472
|
Chris@155
|
473 void
|
Chris@148
|
474 FFTDataServer::resume()
|
Chris@148
|
475 {
|
Chris@154
|
476 #ifdef DEBUG_FFT_SERVER
|
Chris@193
|
477 std::cerr << "FFTDataServer(" << this << " [" << (void *)QThread::currentThreadId() << "]): resume" << std::endl;
|
Chris@154
|
478 #endif
|
Chris@183
|
479 Profiler profiler("FFTDataServer::resume", false);
|
Chris@183
|
480
|
Chris@148
|
481 m_suspended = false;
|
Chris@157
|
482 if (m_fillThread) {
|
Chris@157
|
483 if (m_fillThread->isFinished()) {
|
Chris@157
|
484 delete m_fillThread;
|
Chris@157
|
485 m_fillThread = 0;
|
Chris@157
|
486 deleteProcessingData();
|
Chris@157
|
487 } else {
|
Chris@157
|
488 m_condition.wakeAll();
|
Chris@157
|
489 }
|
Chris@157
|
490 }
|
Chris@148
|
491 }
|
Chris@148
|
492
|
Chris@148
|
493 FFTCache *
|
Chris@148
|
494 FFTDataServer::getCacheAux(size_t c)
|
Chris@148
|
495 {
|
Chris@183
|
496 Profiler profiler("FFTDataServer::getCacheAux", false);
|
Chris@193
|
497 #ifdef DEBUG_FFT_SERVER
|
Chris@193
|
498 std::cerr << "FFTDataServer(" << this << " [" << (void *)QThread::currentThreadId() << "])::getCacheAux" << std::endl;
|
Chris@193
|
499 #endif
|
Chris@183
|
500
|
Chris@148
|
501 QMutexLocker locker(&m_writeMutex);
|
Chris@148
|
502
|
Chris@148
|
503 if (m_lastUsedCache == -1) {
|
Chris@148
|
504 m_fillThread->start();
|
Chris@148
|
505 }
|
Chris@148
|
506
|
Chris@148
|
507 if (int(c) != m_lastUsedCache) {
|
Chris@148
|
508
|
Chris@148
|
509 // std::cerr << "switch from " << m_lastUsedCache << " to " << c << std::endl;
|
Chris@148
|
510
|
Chris@148
|
511 for (IntQueue::iterator i = m_dormantCaches.begin();
|
Chris@148
|
512 i != m_dormantCaches.end(); ++i) {
|
Chris@148
|
513 if (*i == c) {
|
Chris@148
|
514 m_dormantCaches.erase(i);
|
Chris@148
|
515 break;
|
Chris@148
|
516 }
|
Chris@148
|
517 }
|
Chris@148
|
518
|
Chris@148
|
519 if (m_lastUsedCache >= 0) {
|
Chris@148
|
520 bool inDormant = false;
|
Chris@148
|
521 for (size_t i = 0; i < m_dormantCaches.size(); ++i) {
|
Chris@148
|
522 if (m_dormantCaches[i] == m_lastUsedCache) {
|
Chris@148
|
523 inDormant = true;
|
Chris@148
|
524 break;
|
Chris@148
|
525 }
|
Chris@148
|
526 }
|
Chris@148
|
527 if (!inDormant) {
|
Chris@148
|
528 m_dormantCaches.push_back(m_lastUsedCache);
|
Chris@148
|
529 }
|
Chris@148
|
530 while (m_dormantCaches.size() > 4) {
|
Chris@148
|
531 int dc = m_dormantCaches.front();
|
Chris@148
|
532 m_dormantCaches.pop_front();
|
Chris@148
|
533 m_caches[dc]->suspend();
|
Chris@148
|
534 }
|
Chris@148
|
535 }
|
Chris@148
|
536 }
|
Chris@148
|
537
|
Chris@148
|
538 if (m_caches[c]) {
|
Chris@148
|
539 m_lastUsedCache = c;
|
Chris@148
|
540 return m_caches[c];
|
Chris@148
|
541 }
|
Chris@148
|
542
|
Chris@148
|
543 QString name = QString("%1-%2").arg(m_fileBaseName).arg(c);
|
Chris@148
|
544
|
Chris@172
|
545 FFTCache *cache = 0;
|
Chris@172
|
546
|
Chris@172
|
547 if (m_memoryCache) {
|
Chris@172
|
548
|
Chris@172
|
549 cache = new FFTMemoryCache();
|
Chris@172
|
550
|
Chris@172
|
551 } else if (m_compactCache) {
|
Chris@172
|
552
|
Chris@172
|
553 cache = new FFTFileCache(name, MatrixFile::ReadWrite,
|
Chris@172
|
554 FFTFileCache::Compact);
|
Chris@172
|
555
|
Chris@172
|
556 } else {
|
Chris@172
|
557
|
Chris@172
|
558 cache = new FFTFileCache(name, MatrixFile::ReadWrite,
|
Chris@172
|
559 m_polar ? FFTFileCache::Polar :
|
Chris@172
|
560 FFTFileCache::Rectangular);
|
Chris@172
|
561 }
|
Chris@148
|
562
|
Chris@159
|
563 // FFTCache *cache = new FFTMemoryCache();
|
Chris@159
|
564
|
Chris@148
|
565 size_t width = m_cacheWidth;
|
Chris@148
|
566 if (c * m_cacheWidth + width > m_width) {
|
Chris@148
|
567 width = m_width - c * m_cacheWidth;
|
Chris@148
|
568 }
|
Chris@148
|
569
|
Chris@148
|
570 cache->resize(width, m_height);
|
Chris@148
|
571 cache->reset();
|
Chris@148
|
572
|
Chris@148
|
573 m_caches[c] = cache;
|
Chris@148
|
574 m_lastUsedCache = c;
|
Chris@148
|
575
|
Chris@148
|
576 return cache;
|
Chris@148
|
577 }
|
Chris@148
|
578
|
Chris@148
|
579 float
|
Chris@148
|
580 FFTDataServer::getMagnitudeAt(size_t x, size_t y)
|
Chris@148
|
581 {
|
Chris@183
|
582 Profiler profiler("FFTDataServer::getMagnitudeAt", false);
|
Chris@183
|
583
|
Chris@148
|
584 size_t col;
|
Chris@148
|
585 FFTCache *cache = getCache(x, col);
|
Chris@148
|
586
|
Chris@148
|
587 if (!cache->haveSetColumnAt(col)) {
|
Chris@183
|
588 std::cerr << "FFTDataServer::getMagnitudeAt: calling fillColumn("
|
Chris@183
|
589 << x << ")" << std::endl;
|
Chris@148
|
590 fillColumn(x);
|
Chris@148
|
591 }
|
Chris@148
|
592 return cache->getMagnitudeAt(col, y);
|
Chris@148
|
593 }
|
Chris@148
|
594
|
Chris@148
|
595 float
|
Chris@148
|
596 FFTDataServer::getNormalizedMagnitudeAt(size_t x, size_t y)
|
Chris@148
|
597 {
|
Chris@183
|
598 Profiler profiler("FFTDataServer::getNormalizedMagnitudeAt", false);
|
Chris@183
|
599
|
Chris@148
|
600 size_t col;
|
Chris@148
|
601 FFTCache *cache = getCache(x, col);
|
Chris@148
|
602
|
Chris@148
|
603 if (!cache->haveSetColumnAt(col)) {
|
Chris@148
|
604 fillColumn(x);
|
Chris@148
|
605 }
|
Chris@148
|
606 return cache->getNormalizedMagnitudeAt(col, y);
|
Chris@148
|
607 }
|
Chris@148
|
608
|
Chris@148
|
609 float
|
Chris@148
|
610 FFTDataServer::getMaximumMagnitudeAt(size_t x)
|
Chris@148
|
611 {
|
Chris@183
|
612 Profiler profiler("FFTDataServer::getMaximumMagnitudeAt", false);
|
Chris@183
|
613
|
Chris@148
|
614 size_t col;
|
Chris@148
|
615 FFTCache *cache = getCache(x, col);
|
Chris@148
|
616
|
Chris@148
|
617 if (!cache->haveSetColumnAt(col)) {
|
Chris@148
|
618 fillColumn(x);
|
Chris@148
|
619 }
|
Chris@148
|
620 return cache->getMaximumMagnitudeAt(col);
|
Chris@148
|
621 }
|
Chris@148
|
622
|
Chris@148
|
623 float
|
Chris@148
|
624 FFTDataServer::getPhaseAt(size_t x, size_t y)
|
Chris@148
|
625 {
|
Chris@183
|
626 Profiler profiler("FFTDataServer::getPhaseAt", false);
|
Chris@183
|
627
|
Chris@148
|
628 size_t col;
|
Chris@148
|
629 FFTCache *cache = getCache(x, col);
|
Chris@148
|
630
|
Chris@148
|
631 if (!cache->haveSetColumnAt(col)) {
|
Chris@148
|
632 fillColumn(x);
|
Chris@148
|
633 }
|
Chris@148
|
634 return cache->getPhaseAt(col, y);
|
Chris@148
|
635 }
|
Chris@148
|
636
|
Chris@148
|
637 void
|
Chris@148
|
638 FFTDataServer::getValuesAt(size_t x, size_t y, float &real, float &imaginary)
|
Chris@148
|
639 {
|
Chris@183
|
640 Profiler profiler("FFTDataServer::getValuesAt", false);
|
Chris@183
|
641
|
Chris@148
|
642 size_t col;
|
Chris@148
|
643 FFTCache *cache = getCache(x, col);
|
Chris@148
|
644
|
Chris@148
|
645 if (!cache->haveSetColumnAt(col)) {
|
Chris@148
|
646 #ifdef DEBUG_FFT_SERVER
|
Chris@148
|
647 std::cerr << "FFTDataServer::getValuesAt(" << x << ", " << y << "): filling" << std::endl;
|
Chris@148
|
648 #endif
|
Chris@148
|
649 fillColumn(x);
|
Chris@148
|
650 }
|
Chris@148
|
651 float magnitude = cache->getMagnitudeAt(col, y);
|
Chris@148
|
652 float phase = cache->getPhaseAt(col, y);
|
Chris@148
|
653 real = magnitude * cosf(phase);
|
Chris@148
|
654 imaginary = magnitude * sinf(phase);
|
Chris@148
|
655 }
|
Chris@148
|
656
|
Chris@148
|
657 bool
|
Chris@148
|
658 FFTDataServer::isColumnReady(size_t x)
|
Chris@148
|
659 {
|
Chris@183
|
660 Profiler profiler("FFTDataServer::isColumnReady", false);
|
Chris@183
|
661
|
Chris@148
|
662 if (!haveCache(x)) {
|
Chris@148
|
663 if (m_lastUsedCache == -1) {
|
Chris@183
|
664 if (m_suspended) {
|
Chris@183
|
665 std::cerr << "FFTDataServer::isColumnReady(" << x << "): no cache, calling resume" << std::endl;
|
Chris@183
|
666 resume();
|
Chris@183
|
667 }
|
Chris@148
|
668 m_fillThread->start();
|
Chris@148
|
669 }
|
Chris@148
|
670 return false;
|
Chris@148
|
671 }
|
Chris@148
|
672
|
Chris@148
|
673 size_t col;
|
Chris@148
|
674 FFTCache *cache = getCache(x, col);
|
Chris@148
|
675
|
Chris@148
|
676 return cache->haveSetColumnAt(col);
|
Chris@148
|
677 }
|
Chris@148
|
678
|
Chris@148
|
679 void
|
Chris@148
|
680 FFTDataServer::fillColumn(size_t x)
|
Chris@148
|
681 {
|
Chris@183
|
682 Profiler profiler("FFTDataServer::fillColumn", false);
|
Chris@183
|
683
|
Chris@148
|
684 size_t col;
|
Chris@148
|
685 #ifdef DEBUG_FFT_SERVER_FILL
|
Chris@148
|
686 std::cout << "FFTDataServer::fillColumn(" << x << ")" << std::endl;
|
Chris@148
|
687 #endif
|
Chris@148
|
688 FFTCache *cache = getCache(x, col);
|
Chris@148
|
689
|
Chris@148
|
690 QMutexLocker locker(&m_writeMutex);
|
Chris@148
|
691
|
Chris@148
|
692 if (cache->haveSetColumnAt(col)) return;
|
Chris@148
|
693
|
Chris@148
|
694 int startFrame = m_windowIncrement * x;
|
Chris@148
|
695 int endFrame = startFrame + m_windowSize;
|
Chris@148
|
696
|
Chris@148
|
697 startFrame -= int(m_windowSize - m_windowIncrement) / 2;
|
Chris@148
|
698 endFrame -= int(m_windowSize - m_windowIncrement) / 2;
|
Chris@148
|
699 size_t pfx = 0;
|
Chris@148
|
700
|
Chris@148
|
701 size_t off = (m_fftSize - m_windowSize) / 2;
|
Chris@148
|
702
|
Chris@148
|
703 for (size_t i = 0; i < off; ++i) {
|
Chris@148
|
704 m_fftInput[i] = 0.0;
|
Chris@148
|
705 m_fftInput[m_fftSize - i - 1] = 0.0;
|
Chris@148
|
706 }
|
Chris@148
|
707
|
Chris@148
|
708 if (startFrame < 0) {
|
Chris@148
|
709 pfx = size_t(-startFrame);
|
Chris@148
|
710 for (size_t i = 0; i < pfx; ++i) {
|
Chris@148
|
711 m_fftInput[off + i] = 0.0;
|
Chris@148
|
712 }
|
Chris@148
|
713 }
|
Chris@148
|
714
|
Chris@193
|
715 std::cerr << "FFTDataServer::fillColumn: requesting frames "
|
Chris@193
|
716 << startFrame + pfx << " -> " << endFrame << " ( = "
|
Chris@193
|
717 << endFrame - (startFrame + pfx) << ") at index "
|
Chris@193
|
718 << off + pfx << " in buffer of size " << m_fftSize
|
Chris@193
|
719 << " with window size " << m_windowSize
|
Chris@193
|
720 << " from channel " << m_channel << std::endl;
|
Chris@193
|
721
|
Chris@148
|
722 size_t got = m_model->getValues(m_channel, startFrame + pfx,
|
Chris@148
|
723 endFrame, m_fftInput + off + pfx);
|
Chris@148
|
724
|
Chris@148
|
725 while (got + pfx < m_windowSize) {
|
Chris@148
|
726 m_fftInput[off + got + pfx] = 0.0;
|
Chris@148
|
727 ++got;
|
Chris@148
|
728 }
|
Chris@148
|
729
|
Chris@148
|
730 if (m_channel == -1) {
|
Chris@148
|
731 int channels = m_model->getChannelCount();
|
Chris@148
|
732 if (channels > 1) {
|
Chris@148
|
733 for (size_t i = 0; i < m_windowSize; ++i) {
|
Chris@148
|
734 m_fftInput[off + i] /= channels;
|
Chris@148
|
735 }
|
Chris@148
|
736 }
|
Chris@148
|
737 }
|
Chris@148
|
738
|
Chris@148
|
739 m_windower.cut(m_fftInput + off);
|
Chris@148
|
740
|
Chris@148
|
741 for (size_t i = 0; i < m_fftSize/2; ++i) {
|
Chris@148
|
742 fftsample temp = m_fftInput[i];
|
Chris@148
|
743 m_fftInput[i] = m_fftInput[i + m_fftSize/2];
|
Chris@148
|
744 m_fftInput[i + m_fftSize/2] = temp;
|
Chris@148
|
745 }
|
Chris@148
|
746
|
Chris@148
|
747 fftwf_execute(m_fftPlan);
|
Chris@148
|
748
|
Chris@148
|
749 fftsample factor = 0.0;
|
Chris@148
|
750
|
Chris@148
|
751 for (size_t i = 0; i < m_fftSize/2; ++i) {
|
Chris@148
|
752
|
Chris@148
|
753 fftsample mag = sqrtf(m_fftOutput[i][0] * m_fftOutput[i][0] +
|
Chris@148
|
754 m_fftOutput[i][1] * m_fftOutput[i][1]);
|
Chris@148
|
755 mag /= m_windowSize / 2;
|
Chris@148
|
756
|
Chris@148
|
757 if (mag > factor) factor = mag;
|
Chris@148
|
758
|
Chris@148
|
759 fftsample phase = atan2f(m_fftOutput[i][1], m_fftOutput[i][0]);
|
Chris@148
|
760 phase = princargf(phase);
|
Chris@148
|
761
|
Chris@148
|
762 m_workbuffer[i] = mag;
|
Chris@148
|
763 m_workbuffer[i + m_fftSize/2] = phase;
|
Chris@148
|
764 }
|
Chris@148
|
765
|
Chris@148
|
766 cache->setColumnAt(col,
|
Chris@148
|
767 m_workbuffer,
|
Chris@148
|
768 m_workbuffer + m_fftSize/2,
|
Chris@148
|
769 factor);
|
Chris@154
|
770
|
Chris@183
|
771 if (m_suspended) {
|
Chris@183
|
772 // std::cerr << "FFTDataServer::fillColumn(" << x << "): calling resume" << std::endl;
|
Chris@183
|
773 // resume();
|
Chris@183
|
774 }
|
Chris@148
|
775 }
|
Chris@148
|
776
|
Chris@148
|
777 size_t
|
Chris@148
|
778 FFTDataServer::getFillCompletion() const
|
Chris@148
|
779 {
|
Chris@148
|
780 if (m_fillThread) return m_fillThread->getCompletion();
|
Chris@148
|
781 else return 100;
|
Chris@148
|
782 }
|
Chris@148
|
783
|
Chris@148
|
784 size_t
|
Chris@148
|
785 FFTDataServer::getFillExtent() const
|
Chris@148
|
786 {
|
Chris@148
|
787 if (m_fillThread) return m_fillThread->getExtent();
|
Chris@148
|
788 else return m_model->getEndFrame();
|
Chris@148
|
789 }
|
Chris@148
|
790
|
Chris@148
|
791 QString
|
Chris@148
|
792 FFTDataServer::generateFileBasename() const
|
Chris@148
|
793 {
|
Chris@148
|
794 return generateFileBasename(m_model, m_channel, m_windower.getType(),
|
Chris@148
|
795 m_windowSize, m_windowIncrement, m_fftSize,
|
Chris@148
|
796 m_polar);
|
Chris@148
|
797 }
|
Chris@148
|
798
|
Chris@148
|
799 QString
|
Chris@148
|
800 FFTDataServer::generateFileBasename(const DenseTimeValueModel *model,
|
Chris@148
|
801 int channel,
|
Chris@148
|
802 WindowType windowType,
|
Chris@148
|
803 size_t windowSize,
|
Chris@148
|
804 size_t windowIncrement,
|
Chris@148
|
805 size_t fftSize,
|
Chris@148
|
806 bool polar)
|
Chris@148
|
807 {
|
Chris@148
|
808 char buffer[200];
|
Chris@148
|
809
|
Chris@148
|
810 sprintf(buffer, "%u-%u-%u-%u-%u-%u%s",
|
Chris@148
|
811 (unsigned int)XmlExportable::getObjectExportId(model),
|
Chris@148
|
812 (unsigned int)(channel + 1),
|
Chris@148
|
813 (unsigned int)windowType,
|
Chris@148
|
814 (unsigned int)windowSize,
|
Chris@148
|
815 (unsigned int)windowIncrement,
|
Chris@148
|
816 (unsigned int)fftSize,
|
Chris@148
|
817 polar ? "-p" : "-r");
|
Chris@148
|
818
|
Chris@148
|
819 return buffer;
|
Chris@148
|
820 }
|
Chris@148
|
821
|
Chris@148
|
822 void
|
Chris@148
|
823 FFTDataServer::FillThread::run()
|
Chris@148
|
824 {
|
Chris@148
|
825 m_extent = 0;
|
Chris@148
|
826 m_completion = 0;
|
Chris@148
|
827
|
Chris@148
|
828 size_t start = m_server.m_model->getStartFrame();
|
Chris@148
|
829 size_t end = m_server.m_model->getEndFrame();
|
Chris@148
|
830 size_t remainingEnd = end;
|
Chris@148
|
831
|
Chris@148
|
832 int counter = 0;
|
Chris@148
|
833 int updateAt = (end / m_server.m_windowIncrement) / 20;
|
Chris@148
|
834 if (updateAt < 100) updateAt = 100;
|
Chris@148
|
835
|
Chris@148
|
836 if (m_fillFrom > start) {
|
Chris@148
|
837
|
Chris@148
|
838 for (size_t f = m_fillFrom; f < end; f += m_server.m_windowIncrement) {
|
Chris@148
|
839
|
Chris@148
|
840 m_server.fillColumn(int((f - start) / m_server.m_windowIncrement));
|
Chris@148
|
841
|
Chris@148
|
842 if (m_server.m_exiting) return;
|
Chris@148
|
843
|
Chris@148
|
844 while (m_server.m_suspended) {
|
Chris@148
|
845 #ifdef DEBUG_FFT_SERVER
|
Chris@193
|
846 std::cerr << "FFTDataServer(" << this << " [" << (void *)QThread::currentThreadId() << "]): suspended, waiting..." << std::endl;
|
Chris@148
|
847 #endif
|
Chris@148
|
848 m_server.m_writeMutex.lock();
|
Chris@148
|
849 m_server.m_condition.wait(&m_server.m_writeMutex, 10000);
|
Chris@148
|
850 m_server.m_writeMutex.unlock();
|
Chris@159
|
851 #ifdef DEBUG_FFT_SERVER
|
Chris@193
|
852 std::cerr << "FFTDataServer(" << this << " [" << (void *)QThread::currentThreadId() << "]): waited" << std::endl;
|
Chris@159
|
853 #endif
|
Chris@148
|
854 if (m_server.m_exiting) return;
|
Chris@148
|
855 }
|
Chris@148
|
856
|
Chris@148
|
857 if (++counter == updateAt) {
|
Chris@148
|
858 m_extent = f;
|
Chris@148
|
859 m_completion = size_t(100 * fabsf(float(f - m_fillFrom) /
|
Chris@148
|
860 float(end - start)));
|
Chris@148
|
861 counter = 0;
|
Chris@148
|
862 }
|
Chris@148
|
863 }
|
Chris@148
|
864
|
Chris@148
|
865 remainingEnd = m_fillFrom;
|
Chris@148
|
866 if (remainingEnd > start) --remainingEnd;
|
Chris@148
|
867 else remainingEnd = start;
|
Chris@148
|
868 }
|
Chris@148
|
869
|
Chris@148
|
870 size_t baseCompletion = m_completion;
|
Chris@148
|
871
|
Chris@148
|
872 for (size_t f = start; f < remainingEnd; f += m_server.m_windowIncrement) {
|
Chris@148
|
873
|
Chris@148
|
874 m_server.fillColumn(int((f - start) / m_server.m_windowIncrement));
|
Chris@148
|
875
|
Chris@148
|
876 if (m_server.m_exiting) return;
|
Chris@148
|
877
|
Chris@148
|
878 while (m_server.m_suspended) {
|
Chris@148
|
879 #ifdef DEBUG_FFT_SERVER
|
Chris@193
|
880 std::cerr << "FFTDataServer(" << this << " [" << (void *)QThread::currentThreadId() << "]): suspended, waiting..." << std::endl;
|
Chris@148
|
881 #endif
|
Chris@148
|
882 m_server.m_writeMutex.lock();
|
Chris@148
|
883 m_server.m_condition.wait(&m_server.m_writeMutex, 10000);
|
Chris@148
|
884 m_server.m_writeMutex.unlock();
|
Chris@148
|
885 if (m_server.m_exiting) return;
|
Chris@148
|
886 }
|
Chris@148
|
887
|
Chris@148
|
888 if (++counter == updateAt) {
|
Chris@148
|
889 m_extent = f;
|
Chris@148
|
890 m_completion = baseCompletion +
|
Chris@148
|
891 size_t(100 * fabsf(float(f - start) /
|
Chris@148
|
892 float(end - start)));
|
Chris@148
|
893 counter = 0;
|
Chris@148
|
894 }
|
Chris@148
|
895 }
|
Chris@148
|
896
|
Chris@148
|
897 m_completion = 100;
|
Chris@148
|
898 m_extent = end;
|
Chris@148
|
899 }
|
Chris@148
|
900
|