Chris@58
|
1 /* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */
|
Chris@0
|
2
|
Chris@0
|
3 /*
|
Chris@59
|
4 Sonic Visualiser
|
Chris@59
|
5 An audio file viewer and annotation editor.
|
Chris@59
|
6 Centre for Digital Music, Queen Mary, University of London.
|
Chris@59
|
7 This file copyright 2006 Chris Cannam.
|
Chris@0
|
8
|
Chris@59
|
9 This program is free software; you can redistribute it and/or
|
Chris@59
|
10 modify it under the terms of the GNU General Public License as
|
Chris@59
|
11 published by the Free Software Foundation; either version 2 of the
|
Chris@59
|
12 License, or (at your option) any later version. See the file
|
Chris@59
|
13 COPYING included with this distribution for more information.
|
Chris@0
|
14 */
|
Chris@0
|
15
|
Chris@0
|
16 #include "SpectrogramLayer.h"
|
Chris@0
|
17
|
Chris@128
|
18 #include "view/View.h"
|
Chris@0
|
19 #include "base/Profiler.h"
|
Chris@0
|
20 #include "base/AudioLevel.h"
|
Chris@0
|
21 #include "base/Window.h"
|
Chris@24
|
22 #include "base/Pitch.h"
|
Chris@118
|
23 #include "base/Preferences.h"
|
Chris@128
|
24 #include "data/fft/FFTDataServer.h"
|
Chris@0
|
25
|
Chris@0
|
26 #include <QPainter>
|
Chris@0
|
27 #include <QImage>
|
Chris@0
|
28 #include <QPixmap>
|
Chris@0
|
29 #include <QRect>
|
Chris@0
|
30 #include <QTimer>
|
Chris@92
|
31 #include <QApplication>
|
Chris@0
|
32
|
Chris@0
|
33 #include <iostream>
|
Chris@0
|
34
|
Chris@0
|
35 #include <cassert>
|
Chris@0
|
36 #include <cmath>
|
Chris@0
|
37
|
Chris@119
|
38 //#define DEBUG_SPECTROGRAM_REPAINT 1
|
Chris@0
|
39
|
Chris@44
|
40 SpectrogramLayer::SpectrogramLayer(Configuration config) :
|
Chris@44
|
41 Layer(),
|
Chris@0
|
42 m_model(0),
|
Chris@0
|
43 m_channel(0),
|
Chris@0
|
44 m_windowSize(1024),
|
Chris@0
|
45 m_windowType(HanningWindow),
|
Chris@97
|
46 m_windowHopLevel(2),
|
Chris@109
|
47 m_zeroPadLevel(0),
|
Chris@107
|
48 m_fftSize(1024),
|
Chris@0
|
49 m_gain(1.0),
|
Chris@37
|
50 m_threshold(0.0),
|
Chris@9
|
51 m_colourRotation(0),
|
Chris@119
|
52 m_minFrequency(10),
|
Chris@0
|
53 m_maxFrequency(8000),
|
Chris@0
|
54 m_colourScale(dBColourScale),
|
Chris@0
|
55 m_colourScheme(DefaultColours),
|
Chris@0
|
56 m_frequencyScale(LinearFrequencyScale),
|
Chris@37
|
57 m_binDisplay(AllBins),
|
Chris@36
|
58 m_normalizeColumns(false),
|
Chris@120
|
59 m_normalizeVisibleArea(false),
|
Chris@0
|
60 m_updateTimer(0),
|
Chris@44
|
61 m_candidateFillStartFrame(0),
|
Chris@0
|
62 m_exiting(false)
|
Chris@0
|
63 {
|
Chris@0
|
64 if (config == MelodicRange) {
|
Chris@0
|
65 setWindowSize(8192);
|
Chris@97
|
66 setWindowHopLevel(4);
|
Chris@109
|
67 // setWindowType(ParzenWindow);
|
Chris@0
|
68 setMaxFrequency(1000);
|
Chris@0
|
69 setColourScale(LinearColourScale);
|
Chris@37
|
70 } else if (config == MelodicPeaks) {
|
Chris@37
|
71 setWindowSize(4096);
|
Chris@97
|
72 setWindowHopLevel(5);
|
Chris@109
|
73 // setWindowType(BlackmanWindow);
|
Chris@40
|
74 setMaxFrequency(2000);
|
Chris@37
|
75 setMinFrequency(40);
|
Chris@37
|
76 setFrequencyScale(LogFrequencyScale);
|
Chris@41
|
77 setColourScale(MeterColourScale);
|
Chris@37
|
78 setBinDisplay(PeakFrequencies);
|
Chris@37
|
79 setNormalizeColumns(true);
|
Chris@0
|
80 }
|
Chris@110
|
81
|
Chris@122
|
82 Preferences *prefs = Preferences::getInstance();
|
Chris@122
|
83 connect(prefs, SIGNAL(propertyChanged(PropertyContainer::PropertyName)),
|
Chris@122
|
84 this, SLOT(preferenceChanged(PropertyContainer::PropertyName)));
|
Chris@122
|
85 setWindowType(prefs->getWindowType());
|
Chris@122
|
86
|
Chris@110
|
87 setColourmap();
|
Chris@0
|
88 }
|
Chris@0
|
89
|
Chris@0
|
90 SpectrogramLayer::~SpectrogramLayer()
|
Chris@0
|
91 {
|
Chris@0
|
92 delete m_updateTimer;
|
Chris@0
|
93 m_updateTimer = 0;
|
Chris@0
|
94
|
Chris@130
|
95 invalidateFFTModels();
|
Chris@0
|
96 }
|
Chris@0
|
97
|
Chris@0
|
98 void
|
Chris@0
|
99 SpectrogramLayer::setModel(const DenseTimeValueModel *model)
|
Chris@0
|
100 {
|
Chris@101
|
101 // std::cerr << "SpectrogramLayer(" << this << "): setModel(" << model << ")" << std::endl;
|
Chris@34
|
102
|
Chris@110
|
103 if (model == m_model) return;
|
Chris@110
|
104
|
Chris@0
|
105 m_model = model;
|
Chris@130
|
106 invalidateFFTModels();
|
Chris@0
|
107
|
Chris@0
|
108 if (!m_model || !m_model->isOK()) return;
|
Chris@0
|
109
|
Chris@0
|
110 connect(m_model, SIGNAL(modelChanged()), this, SIGNAL(modelChanged()));
|
Chris@0
|
111 connect(m_model, SIGNAL(modelChanged(size_t, size_t)),
|
Chris@0
|
112 this, SIGNAL(modelChanged(size_t, size_t)));
|
Chris@0
|
113
|
Chris@0
|
114 connect(m_model, SIGNAL(completionChanged()),
|
Chris@0
|
115 this, SIGNAL(modelCompletionChanged()));
|
Chris@0
|
116
|
Chris@0
|
117 connect(m_model, SIGNAL(modelChanged()), this, SLOT(cacheInvalid()));
|
Chris@0
|
118 connect(m_model, SIGNAL(modelChanged(size_t, size_t)),
|
Chris@0
|
119 this, SLOT(cacheInvalid(size_t, size_t)));
|
Chris@0
|
120
|
Chris@0
|
121 emit modelReplaced();
|
Chris@110
|
122 }
|
Chris@115
|
123
|
Chris@0
|
124 Layer::PropertyList
|
Chris@0
|
125 SpectrogramLayer::getProperties() const
|
Chris@0
|
126 {
|
Chris@0
|
127 PropertyList list;
|
Chris@87
|
128 list.push_back("Colour");
|
Chris@87
|
129 list.push_back("Colour Scale");
|
Chris@109
|
130 // list.push_back("Window Type");
|
Chris@87
|
131 list.push_back("Window Size");
|
Chris@97
|
132 list.push_back("Window Increment");
|
Chris@87
|
133 list.push_back("Normalize Columns");
|
Chris@120
|
134 list.push_back("Normalize Visible Area");
|
Chris@87
|
135 list.push_back("Bin Display");
|
Chris@87
|
136 list.push_back("Threshold");
|
Chris@87
|
137 list.push_back("Gain");
|
Chris@87
|
138 list.push_back("Colour Rotation");
|
Chris@87
|
139 list.push_back("Min Frequency");
|
Chris@87
|
140 list.push_back("Max Frequency");
|
Chris@87
|
141 list.push_back("Frequency Scale");
|
Chris@111
|
142 // list.push_back("Zero Padding");
|
Chris@0
|
143 return list;
|
Chris@0
|
144 }
|
Chris@0
|
145
|
Chris@87
|
146 QString
|
Chris@87
|
147 SpectrogramLayer::getPropertyLabel(const PropertyName &name) const
|
Chris@87
|
148 {
|
Chris@87
|
149 if (name == "Colour") return tr("Colour");
|
Chris@87
|
150 if (name == "Colour Scale") return tr("Colour Scale");
|
Chris@87
|
151 if (name == "Window Type") return tr("Window Type");
|
Chris@87
|
152 if (name == "Window Size") return tr("Window Size");
|
Chris@112
|
153 if (name == "Window Increment") return tr("Window Overlap");
|
Chris@87
|
154 if (name == "Normalize Columns") return tr("Normalize Columns");
|
Chris@120
|
155 if (name == "Normalize Visible Area") return tr("Normalize Visible Area");
|
Chris@87
|
156 if (name == "Bin Display") return tr("Bin Display");
|
Chris@87
|
157 if (name == "Threshold") return tr("Threshold");
|
Chris@87
|
158 if (name == "Gain") return tr("Gain");
|
Chris@87
|
159 if (name == "Colour Rotation") return tr("Colour Rotation");
|
Chris@87
|
160 if (name == "Min Frequency") return tr("Min Frequency");
|
Chris@87
|
161 if (name == "Max Frequency") return tr("Max Frequency");
|
Chris@87
|
162 if (name == "Frequency Scale") return tr("Frequency Scale");
|
Chris@109
|
163 if (name == "Zero Padding") return tr("Smoothing");
|
Chris@87
|
164 return "";
|
Chris@87
|
165 }
|
Chris@87
|
166
|
Chris@0
|
167 Layer::PropertyType
|
Chris@0
|
168 SpectrogramLayer::getPropertyType(const PropertyName &name) const
|
Chris@0
|
169 {
|
Chris@87
|
170 if (name == "Gain") return RangeProperty;
|
Chris@87
|
171 if (name == "Colour Rotation") return RangeProperty;
|
Chris@87
|
172 if (name == "Normalize Columns") return ToggleProperty;
|
Chris@120
|
173 if (name == "Normalize Visible Area") return ToggleProperty;
|
Chris@87
|
174 if (name == "Threshold") return RangeProperty;
|
Chris@109
|
175 if (name == "Zero Padding") return ToggleProperty;
|
Chris@0
|
176 return ValueProperty;
|
Chris@0
|
177 }
|
Chris@0
|
178
|
Chris@0
|
179 QString
|
Chris@0
|
180 SpectrogramLayer::getPropertyGroupName(const PropertyName &name) const
|
Chris@0
|
181 {
|
Chris@87
|
182 if (name == "Window Size" ||
|
Chris@87
|
183 name == "Window Type" ||
|
Chris@109
|
184 name == "Window Increment" ||
|
Chris@109
|
185 name == "Zero Padding") return tr("Window");
|
Chris@87
|
186 if (name == "Colour" ||
|
Chris@87
|
187 name == "Gain" ||
|
Chris@87
|
188 name == "Threshold" ||
|
Chris@87
|
189 name == "Colour Rotation") return tr("Colour");
|
Chris@87
|
190 if (name == "Normalize Columns" ||
|
Chris@120
|
191 name == "Normalize Visible Area" ||
|
Chris@87
|
192 name == "Bin Display" ||
|
Chris@87
|
193 name == "Colour Scale") return tr("Scale");
|
Chris@87
|
194 if (name == "Max Frequency" ||
|
Chris@87
|
195 name == "Min Frequency" ||
|
Chris@87
|
196 name == "Frequency Scale" ||
|
Chris@87
|
197 name == "Frequency Adjustment") return tr("Range");
|
Chris@0
|
198 return QString();
|
Chris@0
|
199 }
|
Chris@0
|
200
|
Chris@0
|
201 int
|
Chris@0
|
202 SpectrogramLayer::getPropertyRangeAndValue(const PropertyName &name,
|
Chris@55
|
203 int *min, int *max) const
|
Chris@0
|
204 {
|
Chris@0
|
205 int deft = 0;
|
Chris@0
|
206
|
Chris@55
|
207 int garbage0, garbage1;
|
Chris@55
|
208 if (!min) min = &garbage0;
|
Chris@55
|
209 if (!max) max = &garbage1;
|
Chris@10
|
210
|
Chris@87
|
211 if (name == "Gain") {
|
Chris@0
|
212
|
Chris@0
|
213 *min = -50;
|
Chris@0
|
214 *max = 50;
|
Chris@0
|
215
|
Chris@0
|
216 deft = lrint(log10(m_gain) * 20.0);
|
Chris@0
|
217 if (deft < *min) deft = *min;
|
Chris@0
|
218 if (deft > *max) deft = *max;
|
Chris@0
|
219
|
Chris@87
|
220 } else if (name == "Threshold") {
|
Chris@37
|
221
|
Chris@37
|
222 *min = -50;
|
Chris@37
|
223 *max = 0;
|
Chris@37
|
224
|
Chris@37
|
225 deft = lrintf(AudioLevel::multiplier_to_dB(m_threshold));
|
Chris@37
|
226 if (deft < *min) deft = *min;
|
Chris@37
|
227 if (deft > *max) deft = *max;
|
Chris@37
|
228
|
Chris@87
|
229 } else if (name == "Colour Rotation") {
|
Chris@9
|
230
|
Chris@9
|
231 *min = 0;
|
Chris@9
|
232 *max = 256;
|
Chris@9
|
233
|
Chris@9
|
234 deft = m_colourRotation;
|
Chris@9
|
235
|
Chris@87
|
236 } else if (name == "Colour Scale") {
|
Chris@0
|
237
|
Chris@0
|
238 *min = 0;
|
Chris@0
|
239 *max = 3;
|
Chris@0
|
240
|
Chris@0
|
241 deft = (int)m_colourScale;
|
Chris@0
|
242
|
Chris@87
|
243 } else if (name == "Colour") {
|
Chris@0
|
244
|
Chris@0
|
245 *min = 0;
|
Chris@71
|
246 *max = 6;
|
Chris@0
|
247
|
Chris@0
|
248 deft = (int)m_colourScheme;
|
Chris@0
|
249
|
Chris@87
|
250 } else if (name == "Window Type") {
|
Chris@0
|
251
|
Chris@0
|
252 *min = 0;
|
Chris@0
|
253 *max = 6;
|
Chris@0
|
254
|
Chris@0
|
255 deft = (int)m_windowType;
|
Chris@0
|
256
|
Chris@87
|
257 } else if (name == "Window Size") {
|
Chris@0
|
258
|
Chris@0
|
259 *min = 0;
|
Chris@0
|
260 *max = 10;
|
Chris@0
|
261
|
Chris@0
|
262 deft = 0;
|
Chris@0
|
263 int ws = m_windowSize;
|
Chris@0
|
264 while (ws > 32) { ws >>= 1; deft ++; }
|
Chris@0
|
265
|
Chris@97
|
266 } else if (name == "Window Increment") {
|
Chris@0
|
267
|
Chris@0
|
268 *min = 0;
|
Chris@97
|
269 *max = 5;
|
Chris@0
|
270
|
Chris@97
|
271 deft = m_windowHopLevel;
|
Chris@0
|
272
|
Chris@109
|
273 } else if (name == "Zero Padding") {
|
Chris@109
|
274
|
Chris@109
|
275 *min = 0;
|
Chris@109
|
276 *max = 1;
|
Chris@109
|
277
|
Chris@109
|
278 deft = m_zeroPadLevel > 0 ? 1 : 0;
|
Chris@109
|
279
|
Chris@87
|
280 } else if (name == "Min Frequency") {
|
Chris@37
|
281
|
Chris@37
|
282 *min = 0;
|
Chris@37
|
283 *max = 9;
|
Chris@37
|
284
|
Chris@37
|
285 switch (m_minFrequency) {
|
Chris@37
|
286 case 0: default: deft = 0; break;
|
Chris@37
|
287 case 10: deft = 1; break;
|
Chris@37
|
288 case 20: deft = 2; break;
|
Chris@37
|
289 case 40: deft = 3; break;
|
Chris@37
|
290 case 100: deft = 4; break;
|
Chris@37
|
291 case 250: deft = 5; break;
|
Chris@37
|
292 case 500: deft = 6; break;
|
Chris@37
|
293 case 1000: deft = 7; break;
|
Chris@37
|
294 case 4000: deft = 8; break;
|
Chris@37
|
295 case 10000: deft = 9; break;
|
Chris@37
|
296 }
|
Chris@37
|
297
|
Chris@87
|
298 } else if (name == "Max Frequency") {
|
Chris@0
|
299
|
Chris@0
|
300 *min = 0;
|
Chris@0
|
301 *max = 9;
|
Chris@0
|
302
|
Chris@0
|
303 switch (m_maxFrequency) {
|
Chris@0
|
304 case 500: deft = 0; break;
|
Chris@0
|
305 case 1000: deft = 1; break;
|
Chris@0
|
306 case 1500: deft = 2; break;
|
Chris@0
|
307 case 2000: deft = 3; break;
|
Chris@0
|
308 case 4000: deft = 4; break;
|
Chris@0
|
309 case 6000: deft = 5; break;
|
Chris@0
|
310 case 8000: deft = 6; break;
|
Chris@0
|
311 case 12000: deft = 7; break;
|
Chris@0
|
312 case 16000: deft = 8; break;
|
Chris@0
|
313 default: deft = 9; break;
|
Chris@0
|
314 }
|
Chris@0
|
315
|
Chris@87
|
316 } else if (name == "Frequency Scale") {
|
Chris@0
|
317
|
Chris@0
|
318 *min = 0;
|
Chris@0
|
319 *max = 1;
|
Chris@0
|
320 deft = (int)m_frequencyScale;
|
Chris@0
|
321
|
Chris@87
|
322 } else if (name == "Bin Display") {
|
Chris@35
|
323
|
Chris@35
|
324 *min = 0;
|
Chris@35
|
325 *max = 2;
|
Chris@37
|
326 deft = (int)m_binDisplay;
|
Chris@35
|
327
|
Chris@87
|
328 } else if (name == "Normalize Columns") {
|
Chris@36
|
329
|
Chris@36
|
330 deft = (m_normalizeColumns ? 1 : 0);
|
Chris@36
|
331
|
Chris@120
|
332 } else if (name == "Normalize Visible Area") {
|
Chris@120
|
333
|
Chris@120
|
334 deft = (m_normalizeVisibleArea ? 1 : 0);
|
Chris@120
|
335
|
Chris@0
|
336 } else {
|
Chris@0
|
337 deft = Layer::getPropertyRangeAndValue(name, min, max);
|
Chris@0
|
338 }
|
Chris@0
|
339
|
Chris@0
|
340 return deft;
|
Chris@0
|
341 }
|
Chris@0
|
342
|
Chris@0
|
343 QString
|
Chris@0
|
344 SpectrogramLayer::getPropertyValueLabel(const PropertyName &name,
|
Chris@9
|
345 int value) const
|
Chris@0
|
346 {
|
Chris@87
|
347 if (name == "Colour") {
|
Chris@0
|
348 switch (value) {
|
Chris@0
|
349 default:
|
Chris@0
|
350 case 0: return tr("Default");
|
Chris@0
|
351 case 1: return tr("White on Black");
|
Chris@0
|
352 case 2: return tr("Black on White");
|
Chris@0
|
353 case 3: return tr("Red on Blue");
|
Chris@0
|
354 case 4: return tr("Yellow on Black");
|
Chris@71
|
355 case 5: return tr("Blue on Black");
|
Chris@71
|
356 case 6: return tr("Fruit Salad");
|
Chris@0
|
357 }
|
Chris@0
|
358 }
|
Chris@87
|
359 if (name == "Colour Scale") {
|
Chris@0
|
360 switch (value) {
|
Chris@0
|
361 default:
|
Chris@37
|
362 case 0: return tr("Linear");
|
Chris@37
|
363 case 1: return tr("Meter");
|
Chris@37
|
364 case 2: return tr("dB");
|
Chris@119
|
365 case 3: return tr("Other");
|
Chris@119
|
366 case 4: return tr("Phase");
|
Chris@0
|
367 }
|
Chris@0
|
368 }
|
Chris@87
|
369 if (name == "Window Type") {
|
Chris@0
|
370 switch ((WindowType)value) {
|
Chris@0
|
371 default:
|
Chris@35
|
372 case RectangularWindow: return tr("Rectangle");
|
Chris@0
|
373 case BartlettWindow: return tr("Bartlett");
|
Chris@0
|
374 case HammingWindow: return tr("Hamming");
|
Chris@0
|
375 case HanningWindow: return tr("Hanning");
|
Chris@0
|
376 case BlackmanWindow: return tr("Blackman");
|
Chris@0
|
377 case GaussianWindow: return tr("Gaussian");
|
Chris@0
|
378 case ParzenWindow: return tr("Parzen");
|
Chris@0
|
379 }
|
Chris@0
|
380 }
|
Chris@87
|
381 if (name == "Window Size") {
|
Chris@0
|
382 return QString("%1").arg(32 << value);
|
Chris@0
|
383 }
|
Chris@97
|
384 if (name == "Window Increment") {
|
Chris@0
|
385 switch (value) {
|
Chris@0
|
386 default:
|
Chris@112
|
387 case 0: return tr("None");
|
Chris@112
|
388 case 1: return tr("25 %");
|
Chris@112
|
389 case 2: return tr("50 %");
|
Chris@112
|
390 case 3: return tr("75 %");
|
Chris@112
|
391 case 4: return tr("87.5 %");
|
Chris@112
|
392 case 5: return tr("93.75 %");
|
Chris@0
|
393 }
|
Chris@0
|
394 }
|
Chris@109
|
395 if (name == "Zero Padding") {
|
Chris@109
|
396 if (value == 0) return tr("None");
|
Chris@109
|
397 return QString("%1x").arg(value + 1);
|
Chris@109
|
398 }
|
Chris@87
|
399 if (name == "Min Frequency") {
|
Chris@37
|
400 switch (value) {
|
Chris@37
|
401 default:
|
Chris@38
|
402 case 0: return tr("No min");
|
Chris@37
|
403 case 1: return tr("10 Hz");
|
Chris@37
|
404 case 2: return tr("20 Hz");
|
Chris@37
|
405 case 3: return tr("40 Hz");
|
Chris@37
|
406 case 4: return tr("100 Hz");
|
Chris@37
|
407 case 5: return tr("250 Hz");
|
Chris@37
|
408 case 6: return tr("500 Hz");
|
Chris@37
|
409 case 7: return tr("1 KHz");
|
Chris@37
|
410 case 8: return tr("4 KHz");
|
Chris@37
|
411 case 9: return tr("10 KHz");
|
Chris@37
|
412 }
|
Chris@37
|
413 }
|
Chris@87
|
414 if (name == "Max Frequency") {
|
Chris@0
|
415 switch (value) {
|
Chris@0
|
416 default:
|
Chris@0
|
417 case 0: return tr("500 Hz");
|
Chris@0
|
418 case 1: return tr("1 KHz");
|
Chris@0
|
419 case 2: return tr("1.5 KHz");
|
Chris@0
|
420 case 3: return tr("2 KHz");
|
Chris@0
|
421 case 4: return tr("4 KHz");
|
Chris@0
|
422 case 5: return tr("6 KHz");
|
Chris@0
|
423 case 6: return tr("8 KHz");
|
Chris@0
|
424 case 7: return tr("12 KHz");
|
Chris@0
|
425 case 8: return tr("16 KHz");
|
Chris@38
|
426 case 9: return tr("No max");
|
Chris@0
|
427 }
|
Chris@0
|
428 }
|
Chris@87
|
429 if (name == "Frequency Scale") {
|
Chris@0
|
430 switch (value) {
|
Chris@0
|
431 default:
|
Chris@0
|
432 case 0: return tr("Linear");
|
Chris@0
|
433 case 1: return tr("Log");
|
Chris@0
|
434 }
|
Chris@0
|
435 }
|
Chris@87
|
436 if (name == "Bin Display") {
|
Chris@35
|
437 switch (value) {
|
Chris@35
|
438 default:
|
Chris@37
|
439 case 0: return tr("All Bins");
|
Chris@37
|
440 case 1: return tr("Peak Bins");
|
Chris@37
|
441 case 2: return tr("Frequencies");
|
Chris@35
|
442 }
|
Chris@35
|
443 }
|
Chris@0
|
444 return tr("<unknown>");
|
Chris@0
|
445 }
|
Chris@0
|
446
|
Chris@0
|
447 void
|
Chris@0
|
448 SpectrogramLayer::setProperty(const PropertyName &name, int value)
|
Chris@0
|
449 {
|
Chris@87
|
450 if (name == "Gain") {
|
Chris@0
|
451 setGain(pow(10, float(value)/20.0));
|
Chris@87
|
452 } else if (name == "Threshold") {
|
Chris@37
|
453 if (value == -50) setThreshold(0.0);
|
Chris@37
|
454 else setThreshold(AudioLevel::dB_to_multiplier(value));
|
Chris@87
|
455 } else if (name == "Colour Rotation") {
|
Chris@9
|
456 setColourRotation(value);
|
Chris@87
|
457 } else if (name == "Colour") {
|
Chris@0
|
458 switch (value) {
|
Chris@0
|
459 default:
|
Chris@0
|
460 case 0: setColourScheme(DefaultColours); break;
|
Chris@0
|
461 case 1: setColourScheme(WhiteOnBlack); break;
|
Chris@0
|
462 case 2: setColourScheme(BlackOnWhite); break;
|
Chris@0
|
463 case 3: setColourScheme(RedOnBlue); break;
|
Chris@0
|
464 case 4: setColourScheme(YellowOnBlack); break;
|
Chris@71
|
465 case 5: setColourScheme(BlueOnBlack); break;
|
Chris@71
|
466 case 6: setColourScheme(Rainbow); break;
|
Chris@0
|
467 }
|
Chris@87
|
468 } else if (name == "Window Type") {
|
Chris@0
|
469 setWindowType(WindowType(value));
|
Chris@87
|
470 } else if (name == "Window Size") {
|
Chris@0
|
471 setWindowSize(32 << value);
|
Chris@97
|
472 } else if (name == "Window Increment") {
|
Chris@97
|
473 setWindowHopLevel(value);
|
Chris@109
|
474 } else if (name == "Zero Padding") {
|
Chris@109
|
475 setZeroPadLevel(value > 0.1 ? 3 : 0);
|
Chris@87
|
476 } else if (name == "Min Frequency") {
|
Chris@37
|
477 switch (value) {
|
Chris@37
|
478 default:
|
Chris@37
|
479 case 0: setMinFrequency(0); break;
|
Chris@37
|
480 case 1: setMinFrequency(10); break;
|
Chris@37
|
481 case 2: setMinFrequency(20); break;
|
Chris@37
|
482 case 3: setMinFrequency(40); break;
|
Chris@37
|
483 case 4: setMinFrequency(100); break;
|
Chris@37
|
484 case 5: setMinFrequency(250); break;
|
Chris@37
|
485 case 6: setMinFrequency(500); break;
|
Chris@37
|
486 case 7: setMinFrequency(1000); break;
|
Chris@37
|
487 case 8: setMinFrequency(4000); break;
|
Chris@37
|
488 case 9: setMinFrequency(10000); break;
|
Chris@37
|
489 }
|
Chris@87
|
490 } else if (name == "Max Frequency") {
|
Chris@0
|
491 switch (value) {
|
Chris@0
|
492 case 0: setMaxFrequency(500); break;
|
Chris@0
|
493 case 1: setMaxFrequency(1000); break;
|
Chris@0
|
494 case 2: setMaxFrequency(1500); break;
|
Chris@0
|
495 case 3: setMaxFrequency(2000); break;
|
Chris@0
|
496 case 4: setMaxFrequency(4000); break;
|
Chris@0
|
497 case 5: setMaxFrequency(6000); break;
|
Chris@0
|
498 case 6: setMaxFrequency(8000); break;
|
Chris@0
|
499 case 7: setMaxFrequency(12000); break;
|
Chris@0
|
500 case 8: setMaxFrequency(16000); break;
|
Chris@0
|
501 default:
|
Chris@0
|
502 case 9: setMaxFrequency(0); break;
|
Chris@0
|
503 }
|
Chris@87
|
504 } else if (name == "Colour Scale") {
|
Chris@0
|
505 switch (value) {
|
Chris@0
|
506 default:
|
Chris@0
|
507 case 0: setColourScale(LinearColourScale); break;
|
Chris@0
|
508 case 1: setColourScale(MeterColourScale); break;
|
Chris@0
|
509 case 2: setColourScale(dBColourScale); break;
|
Chris@119
|
510 case 3: setColourScale(OtherColourScale); break;
|
Chris@119
|
511 case 4: setColourScale(PhaseColourScale); break;
|
Chris@0
|
512 }
|
Chris@87
|
513 } else if (name == "Frequency Scale") {
|
Chris@0
|
514 switch (value) {
|
Chris@0
|
515 default:
|
Chris@0
|
516 case 0: setFrequencyScale(LinearFrequencyScale); break;
|
Chris@0
|
517 case 1: setFrequencyScale(LogFrequencyScale); break;
|
Chris@0
|
518 }
|
Chris@87
|
519 } else if (name == "Bin Display") {
|
Chris@35
|
520 switch (value) {
|
Chris@35
|
521 default:
|
Chris@37
|
522 case 0: setBinDisplay(AllBins); break;
|
Chris@37
|
523 case 1: setBinDisplay(PeakBins); break;
|
Chris@37
|
524 case 2: setBinDisplay(PeakFrequencies); break;
|
Chris@35
|
525 }
|
Chris@82
|
526 } else if (name == "Normalize Columns") {
|
Chris@36
|
527 setNormalizeColumns(value ? true : false);
|
Chris@120
|
528 } else if (name == "Normalize Visible Area") {
|
Chris@120
|
529 setNormalizeVisibleArea(value ? true : false);
|
Chris@0
|
530 }
|
Chris@0
|
531 }
|
Chris@0
|
532
|
Chris@0
|
533 void
|
Chris@95
|
534 SpectrogramLayer::invalidatePixmapCaches()
|
Chris@95
|
535 {
|
Chris@95
|
536 for (ViewPixmapCache::iterator i = m_pixmapCaches.begin();
|
Chris@95
|
537 i != m_pixmapCaches.end(); ++i) {
|
Chris@95
|
538 i->second.validArea = QRect();
|
Chris@95
|
539 }
|
Chris@95
|
540 }
|
Chris@95
|
541
|
Chris@95
|
542 void
|
Chris@95
|
543 SpectrogramLayer::invalidatePixmapCaches(size_t startFrame, size_t endFrame)
|
Chris@95
|
544 {
|
Chris@95
|
545 for (ViewPixmapCache::iterator i = m_pixmapCaches.begin();
|
Chris@95
|
546 i != m_pixmapCaches.end(); ++i) {
|
Chris@95
|
547 //!!! when are views removed from the map? on setLayerDormant?
|
Chris@95
|
548 const View *v = i->first;
|
Chris@95
|
549
|
Chris@115
|
550 if (startFrame < v->getEndFrame() && int(endFrame) >= v->getStartFrame()) {
|
Chris@95
|
551 i->second.validArea = QRect();
|
Chris@95
|
552 }
|
Chris@95
|
553 }
|
Chris@95
|
554 }
|
Chris@95
|
555
|
Chris@95
|
556 void
|
Chris@122
|
557 SpectrogramLayer::preferenceChanged(PropertyContainer::PropertyName name)
|
Chris@122
|
558 {
|
Chris@122
|
559 std::cerr << "SpectrogramLayer::preferenceChanged(" << name.toStdString() << ")" << std::endl;
|
Chris@122
|
560
|
Chris@122
|
561 if (name == "Window Type") {
|
Chris@122
|
562 setWindowType(Preferences::getInstance()->getWindowType());
|
Chris@122
|
563 return;
|
Chris@122
|
564 }
|
Chris@122
|
565 if (name == "Smooth Spectrogram") {
|
Chris@122
|
566 invalidatePixmapCaches();
|
Chris@122
|
567 invalidateMagnitudes();
|
Chris@122
|
568 emit layerParametersChanged();
|
Chris@122
|
569 }
|
Chris@122
|
570 if (name == "Tuning Frequency") {
|
Chris@122
|
571 emit layerParametersChanged();
|
Chris@122
|
572 }
|
Chris@122
|
573 }
|
Chris@122
|
574
|
Chris@122
|
575 void
|
Chris@0
|
576 SpectrogramLayer::setChannel(int ch)
|
Chris@0
|
577 {
|
Chris@0
|
578 if (m_channel == ch) return;
|
Chris@0
|
579
|
Chris@95
|
580 invalidatePixmapCaches();
|
Chris@0
|
581 m_channel = ch;
|
Chris@130
|
582 invalidateFFTModels();
|
Chris@9
|
583
|
Chris@0
|
584 emit layerParametersChanged();
|
Chris@0
|
585 }
|
Chris@0
|
586
|
Chris@0
|
587 int
|
Chris@0
|
588 SpectrogramLayer::getChannel() const
|
Chris@0
|
589 {
|
Chris@0
|
590 return m_channel;
|
Chris@0
|
591 }
|
Chris@0
|
592
|
Chris@0
|
593 void
|
Chris@0
|
594 SpectrogramLayer::setWindowSize(size_t ws)
|
Chris@0
|
595 {
|
Chris@0
|
596 if (m_windowSize == ws) return;
|
Chris@0
|
597
|
Chris@95
|
598 invalidatePixmapCaches();
|
Chris@0
|
599
|
Chris@0
|
600 m_windowSize = ws;
|
Chris@109
|
601 m_fftSize = ws * (m_zeroPadLevel + 1);
|
Chris@0
|
602
|
Chris@130
|
603 invalidateFFTModels();
|
Chris@9
|
604
|
Chris@9
|
605 emit layerParametersChanged();
|
Chris@0
|
606 }
|
Chris@0
|
607
|
Chris@0
|
608 size_t
|
Chris@0
|
609 SpectrogramLayer::getWindowSize() const
|
Chris@0
|
610 {
|
Chris@0
|
611 return m_windowSize;
|
Chris@0
|
612 }
|
Chris@0
|
613
|
Chris@0
|
614 void
|
Chris@97
|
615 SpectrogramLayer::setWindowHopLevel(size_t v)
|
Chris@0
|
616 {
|
Chris@97
|
617 if (m_windowHopLevel == v) return;
|
Chris@0
|
618
|
Chris@95
|
619 invalidatePixmapCaches();
|
Chris@0
|
620
|
Chris@97
|
621 m_windowHopLevel = v;
|
Chris@0
|
622
|
Chris@130
|
623 invalidateFFTModels();
|
Chris@9
|
624
|
Chris@9
|
625 emit layerParametersChanged();
|
Chris@9
|
626
|
Chris@110
|
627 // fillCache();
|
Chris@0
|
628 }
|
Chris@0
|
629
|
Chris@0
|
630 size_t
|
Chris@97
|
631 SpectrogramLayer::getWindowHopLevel() const
|
Chris@0
|
632 {
|
Chris@97
|
633 return m_windowHopLevel;
|
Chris@0
|
634 }
|
Chris@0
|
635
|
Chris@0
|
636 void
|
Chris@109
|
637 SpectrogramLayer::setZeroPadLevel(size_t v)
|
Chris@109
|
638 {
|
Chris@109
|
639 if (m_zeroPadLevel == v) return;
|
Chris@109
|
640
|
Chris@109
|
641 invalidatePixmapCaches();
|
Chris@109
|
642
|
Chris@109
|
643 m_zeroPadLevel = v;
|
Chris@109
|
644 m_fftSize = m_windowSize * (v + 1);
|
Chris@110
|
645
|
Chris@130
|
646 invalidateFFTModels();
|
Chris@109
|
647
|
Chris@109
|
648 emit layerParametersChanged();
|
Chris@109
|
649 }
|
Chris@109
|
650
|
Chris@109
|
651 size_t
|
Chris@109
|
652 SpectrogramLayer::getZeroPadLevel() const
|
Chris@109
|
653 {
|
Chris@109
|
654 return m_zeroPadLevel;
|
Chris@109
|
655 }
|
Chris@109
|
656
|
Chris@109
|
657 void
|
Chris@0
|
658 SpectrogramLayer::setWindowType(WindowType w)
|
Chris@0
|
659 {
|
Chris@0
|
660 if (m_windowType == w) return;
|
Chris@0
|
661
|
Chris@95
|
662 invalidatePixmapCaches();
|
Chris@0
|
663
|
Chris@0
|
664 m_windowType = w;
|
Chris@110
|
665
|
Chris@130
|
666 invalidateFFTModels();
|
Chris@9
|
667
|
Chris@9
|
668 emit layerParametersChanged();
|
Chris@0
|
669 }
|
Chris@0
|
670
|
Chris@0
|
671 WindowType
|
Chris@0
|
672 SpectrogramLayer::getWindowType() const
|
Chris@0
|
673 {
|
Chris@0
|
674 return m_windowType;
|
Chris@0
|
675 }
|
Chris@0
|
676
|
Chris@0
|
677 void
|
Chris@0
|
678 SpectrogramLayer::setGain(float gain)
|
Chris@0
|
679 {
|
Chris@101
|
680 // std::cerr << "SpectrogramLayer::setGain(" << gain << ") (my gain is now "
|
Chris@101
|
681 // << m_gain << ")" << std::endl;
|
Chris@55
|
682
|
Chris@40
|
683 if (m_gain == gain) return;
|
Chris@0
|
684
|
Chris@95
|
685 invalidatePixmapCaches();
|
Chris@0
|
686
|
Chris@0
|
687 m_gain = gain;
|
Chris@0
|
688
|
Chris@9
|
689 emit layerParametersChanged();
|
Chris@0
|
690 }
|
Chris@0
|
691
|
Chris@0
|
692 float
|
Chris@0
|
693 SpectrogramLayer::getGain() const
|
Chris@0
|
694 {
|
Chris@0
|
695 return m_gain;
|
Chris@0
|
696 }
|
Chris@0
|
697
|
Chris@0
|
698 void
|
Chris@37
|
699 SpectrogramLayer::setThreshold(float threshold)
|
Chris@37
|
700 {
|
Chris@40
|
701 if (m_threshold == threshold) return;
|
Chris@37
|
702
|
Chris@95
|
703 invalidatePixmapCaches();
|
Chris@37
|
704
|
Chris@37
|
705 m_threshold = threshold;
|
Chris@37
|
706
|
Chris@37
|
707 emit layerParametersChanged();
|
Chris@37
|
708 }
|
Chris@37
|
709
|
Chris@37
|
710 float
|
Chris@37
|
711 SpectrogramLayer::getThreshold() const
|
Chris@37
|
712 {
|
Chris@37
|
713 return m_threshold;
|
Chris@37
|
714 }
|
Chris@37
|
715
|
Chris@37
|
716 void
|
Chris@37
|
717 SpectrogramLayer::setMinFrequency(size_t mf)
|
Chris@37
|
718 {
|
Chris@37
|
719 if (m_minFrequency == mf) return;
|
Chris@37
|
720
|
Chris@95
|
721 invalidatePixmapCaches();
|
Chris@119
|
722 invalidateMagnitudes();
|
Chris@37
|
723
|
Chris@37
|
724 m_minFrequency = mf;
|
Chris@37
|
725
|
Chris@37
|
726 emit layerParametersChanged();
|
Chris@37
|
727 }
|
Chris@37
|
728
|
Chris@37
|
729 size_t
|
Chris@37
|
730 SpectrogramLayer::getMinFrequency() const
|
Chris@37
|
731 {
|
Chris@37
|
732 return m_minFrequency;
|
Chris@37
|
733 }
|
Chris@37
|
734
|
Chris@37
|
735 void
|
Chris@0
|
736 SpectrogramLayer::setMaxFrequency(size_t mf)
|
Chris@0
|
737 {
|
Chris@0
|
738 if (m_maxFrequency == mf) return;
|
Chris@0
|
739
|
Chris@95
|
740 invalidatePixmapCaches();
|
Chris@119
|
741 invalidateMagnitudes();
|
Chris@0
|
742
|
Chris@0
|
743 m_maxFrequency = mf;
|
Chris@0
|
744
|
Chris@9
|
745 emit layerParametersChanged();
|
Chris@0
|
746 }
|
Chris@0
|
747
|
Chris@0
|
748 size_t
|
Chris@0
|
749 SpectrogramLayer::getMaxFrequency() const
|
Chris@0
|
750 {
|
Chris@0
|
751 return m_maxFrequency;
|
Chris@0
|
752 }
|
Chris@0
|
753
|
Chris@0
|
754 void
|
Chris@9
|
755 SpectrogramLayer::setColourRotation(int r)
|
Chris@9
|
756 {
|
Chris@95
|
757 invalidatePixmapCaches();
|
Chris@9
|
758
|
Chris@9
|
759 if (r < 0) r = 0;
|
Chris@9
|
760 if (r > 256) r = 256;
|
Chris@9
|
761 int distance = r - m_colourRotation;
|
Chris@9
|
762
|
Chris@9
|
763 if (distance != 0) {
|
Chris@90
|
764 rotateColourmap(-distance);
|
Chris@9
|
765 m_colourRotation = r;
|
Chris@9
|
766 }
|
Chris@9
|
767
|
Chris@9
|
768 emit layerParametersChanged();
|
Chris@9
|
769 }
|
Chris@9
|
770
|
Chris@9
|
771 void
|
Chris@0
|
772 SpectrogramLayer::setColourScale(ColourScale colourScale)
|
Chris@0
|
773 {
|
Chris@0
|
774 if (m_colourScale == colourScale) return;
|
Chris@0
|
775
|
Chris@95
|
776 invalidatePixmapCaches();
|
Chris@0
|
777
|
Chris@0
|
778 m_colourScale = colourScale;
|
Chris@0
|
779
|
Chris@9
|
780 emit layerParametersChanged();
|
Chris@0
|
781 }
|
Chris@0
|
782
|
Chris@0
|
783 SpectrogramLayer::ColourScale
|
Chris@0
|
784 SpectrogramLayer::getColourScale() const
|
Chris@0
|
785 {
|
Chris@0
|
786 return m_colourScale;
|
Chris@0
|
787 }
|
Chris@0
|
788
|
Chris@0
|
789 void
|
Chris@0
|
790 SpectrogramLayer::setColourScheme(ColourScheme scheme)
|
Chris@0
|
791 {
|
Chris@0
|
792 if (m_colourScheme == scheme) return;
|
Chris@0
|
793
|
Chris@95
|
794 invalidatePixmapCaches();
|
Chris@0
|
795
|
Chris@0
|
796 m_colourScheme = scheme;
|
Chris@90
|
797 setColourmap();
|
Chris@9
|
798
|
Chris@0
|
799 emit layerParametersChanged();
|
Chris@0
|
800 }
|
Chris@0
|
801
|
Chris@0
|
802 SpectrogramLayer::ColourScheme
|
Chris@0
|
803 SpectrogramLayer::getColourScheme() const
|
Chris@0
|
804 {
|
Chris@0
|
805 return m_colourScheme;
|
Chris@0
|
806 }
|
Chris@0
|
807
|
Chris@0
|
808 void
|
Chris@0
|
809 SpectrogramLayer::setFrequencyScale(FrequencyScale frequencyScale)
|
Chris@0
|
810 {
|
Chris@0
|
811 if (m_frequencyScale == frequencyScale) return;
|
Chris@0
|
812
|
Chris@95
|
813 invalidatePixmapCaches();
|
Chris@0
|
814 m_frequencyScale = frequencyScale;
|
Chris@9
|
815
|
Chris@9
|
816 emit layerParametersChanged();
|
Chris@0
|
817 }
|
Chris@0
|
818
|
Chris@0
|
819 SpectrogramLayer::FrequencyScale
|
Chris@0
|
820 SpectrogramLayer::getFrequencyScale() const
|
Chris@0
|
821 {
|
Chris@0
|
822 return m_frequencyScale;
|
Chris@0
|
823 }
|
Chris@0
|
824
|
Chris@0
|
825 void
|
Chris@37
|
826 SpectrogramLayer::setBinDisplay(BinDisplay binDisplay)
|
Chris@35
|
827 {
|
Chris@37
|
828 if (m_binDisplay == binDisplay) return;
|
Chris@35
|
829
|
Chris@95
|
830 invalidatePixmapCaches();
|
Chris@37
|
831 m_binDisplay = binDisplay;
|
Chris@35
|
832
|
Chris@35
|
833 emit layerParametersChanged();
|
Chris@35
|
834 }
|
Chris@35
|
835
|
Chris@37
|
836 SpectrogramLayer::BinDisplay
|
Chris@37
|
837 SpectrogramLayer::getBinDisplay() const
|
Chris@35
|
838 {
|
Chris@37
|
839 return m_binDisplay;
|
Chris@35
|
840 }
|
Chris@35
|
841
|
Chris@35
|
842 void
|
Chris@36
|
843 SpectrogramLayer::setNormalizeColumns(bool n)
|
Chris@36
|
844 {
|
Chris@36
|
845 if (m_normalizeColumns == n) return;
|
Chris@36
|
846
|
Chris@95
|
847 invalidatePixmapCaches();
|
Chris@119
|
848 invalidateMagnitudes();
|
Chris@36
|
849 m_normalizeColumns = n;
|
Chris@36
|
850
|
Chris@36
|
851 emit layerParametersChanged();
|
Chris@36
|
852 }
|
Chris@36
|
853
|
Chris@36
|
854 bool
|
Chris@36
|
855 SpectrogramLayer::getNormalizeColumns() const
|
Chris@36
|
856 {
|
Chris@36
|
857 return m_normalizeColumns;
|
Chris@36
|
858 }
|
Chris@36
|
859
|
Chris@36
|
860 void
|
Chris@120
|
861 SpectrogramLayer::setNormalizeVisibleArea(bool n)
|
Chris@120
|
862 {
|
Chris@120
|
863 if (m_normalizeVisibleArea == n) return;
|
Chris@120
|
864
|
Chris@120
|
865 invalidatePixmapCaches();
|
Chris@120
|
866 invalidateMagnitudes();
|
Chris@120
|
867 m_normalizeVisibleArea = n;
|
Chris@120
|
868
|
Chris@120
|
869 emit layerParametersChanged();
|
Chris@120
|
870 }
|
Chris@120
|
871
|
Chris@120
|
872 bool
|
Chris@120
|
873 SpectrogramLayer::getNormalizeVisibleArea() const
|
Chris@120
|
874 {
|
Chris@120
|
875 return m_normalizeVisibleArea;
|
Chris@120
|
876 }
|
Chris@120
|
877
|
Chris@120
|
878 void
|
Chris@47
|
879 SpectrogramLayer::setLayerDormant(const View *v, bool dormant)
|
Chris@29
|
880 {
|
Chris@47
|
881 if (dormant == m_dormancy[v]) return;
|
Chris@33
|
882
|
Chris@33
|
883 if (dormant) {
|
Chris@33
|
884
|
Chris@47
|
885 m_dormancy[v] = true;
|
Chris@33
|
886
|
Chris@95
|
887 invalidatePixmapCaches();
|
Chris@95
|
888 m_pixmapCaches.erase(v);
|
Chris@114
|
889
|
Chris@130
|
890 if (m_fftModels.find(v) != m_fftModels.end()) {
|
Chris@130
|
891 delete m_fftModels[v].first;
|
Chris@130
|
892 m_fftModels.erase(v);
|
Chris@114
|
893 }
|
Chris@33
|
894
|
Chris@33
|
895 } else {
|
Chris@33
|
896
|
Chris@47
|
897 m_dormancy[v] = false;
|
Chris@33
|
898 }
|
Chris@29
|
899 }
|
Chris@29
|
900
|
Chris@29
|
901 void
|
Chris@0
|
902 SpectrogramLayer::cacheInvalid()
|
Chris@0
|
903 {
|
Chris@95
|
904 invalidatePixmapCaches();
|
Chris@119
|
905 invalidateMagnitudes();
|
Chris@0
|
906 }
|
Chris@0
|
907
|
Chris@0
|
908 void
|
Chris@0
|
909 SpectrogramLayer::cacheInvalid(size_t, size_t)
|
Chris@0
|
910 {
|
Chris@0
|
911 // for now (or forever?)
|
Chris@0
|
912 cacheInvalid();
|
Chris@0
|
913 }
|
Chris@0
|
914
|
Chris@0
|
915 void
|
Chris@0
|
916 SpectrogramLayer::fillTimerTimedOut()
|
Chris@0
|
917 {
|
Chris@115
|
918 if (!m_model) return;
|
Chris@115
|
919
|
Chris@115
|
920 bool allDone = true;
|
Chris@115
|
921
|
Chris@130
|
922 for (ViewFFTMap::iterator i = m_fftModels.begin();
|
Chris@130
|
923 i != m_fftModels.end(); ++i) {
|
Chris@115
|
924
|
Chris@115
|
925 const View *v = i->first;
|
Chris@130
|
926 const FFTModel *model = i->second.first;
|
Chris@115
|
927 size_t lastFill = i->second.second;
|
Chris@115
|
928
|
Chris@130
|
929 if (model) {
|
Chris@130
|
930
|
Chris@130
|
931 size_t fill = model->getFillExtent();
|
Chris@115
|
932
|
Chris@0
|
933 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@130
|
934 std::cerr << "SpectrogramLayer::fillTimerTimedOut: extent for " << model << ": " << fill << ", last " << lastFill << ", total " << m_model->getEndFrame() << std::endl;
|
Chris@0
|
935 #endif
|
Chris@115
|
936
|
Chris@115
|
937 if (fill >= lastFill) {
|
Chris@115
|
938 if (fill >= m_model->getEndFrame() && lastFill > 0) {
|
Chris@0
|
939 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@115
|
940 std::cerr << "complete!" << std::endl;
|
Chris@0
|
941 #endif
|
Chris@115
|
942 invalidatePixmapCaches();
|
Chris@115
|
943 emit modelChanged();
|
Chris@115
|
944 i->second.second = -1;
|
Chris@115
|
945
|
Chris@115
|
946 } else if (fill > lastFill) {
|
Chris@0
|
947 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@115
|
948 std::cerr << "SpectrogramLayer: emitting modelChanged("
|
Chris@115
|
949 << lastFill << "," << fill << ")" << std::endl;
|
Chris@0
|
950 #endif
|
Chris@115
|
951 invalidatePixmapCaches(lastFill, fill);
|
Chris@115
|
952 emit modelChanged(lastFill, fill);
|
Chris@115
|
953 i->second.second = fill;
|
Chris@115
|
954 }
|
Chris@115
|
955 } else {
|
Chris@0
|
956 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@115
|
957 std::cerr << "SpectrogramLayer: going backwards, emitting modelChanged("
|
Chris@115
|
958 << m_model->getStartFrame() << "," << m_model->getEndFrame() << ")" << std::endl;
|
Chris@0
|
959 #endif
|
Chris@115
|
960 invalidatePixmapCaches();
|
Chris@115
|
961 emit modelChanged(m_model->getStartFrame(), m_model->getEndFrame());
|
Chris@115
|
962 i->second.second = fill;
|
Chris@115
|
963 }
|
Chris@115
|
964
|
Chris@115
|
965 if (i->second.second >= 0) {
|
Chris@115
|
966 allDone = false;
|
Chris@115
|
967 }
|
Chris@115
|
968 }
|
Chris@0
|
969 }
|
Chris@115
|
970
|
Chris@115
|
971 if (allDone) {
|
Chris@115
|
972 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@115
|
973 std::cerr << "SpectrogramLayer: all complete!" << std::endl;
|
Chris@115
|
974 #endif
|
Chris@115
|
975 delete m_updateTimer;
|
Chris@115
|
976 m_updateTimer = 0;
|
Chris@115
|
977 }
|
Chris@0
|
978 }
|
Chris@0
|
979
|
Chris@0
|
980 void
|
Chris@90
|
981 SpectrogramLayer::setColourmap()
|
Chris@0
|
982 {
|
Chris@10
|
983 int formerRotation = m_colourRotation;
|
Chris@10
|
984
|
Chris@38
|
985 if (m_colourScheme == BlackOnWhite) {
|
Chris@86
|
986 m_colourMap.setColour(NO_VALUE, Qt::white);
|
Chris@38
|
987 } else {
|
Chris@86
|
988 m_colourMap.setColour(NO_VALUE, Qt::black);
|
Chris@38
|
989 }
|
Chris@0
|
990
|
Chris@0
|
991 for (int pixel = 1; pixel < 256; ++pixel) {
|
Chris@0
|
992
|
Chris@0
|
993 QColor colour;
|
Chris@0
|
994 int hue, px;
|
Chris@0
|
995
|
Chris@0
|
996 switch (m_colourScheme) {
|
Chris@0
|
997
|
Chris@0
|
998 default:
|
Chris@0
|
999 case DefaultColours:
|
Chris@0
|
1000 hue = 256 - pixel;
|
Chris@0
|
1001 colour = QColor::fromHsv(hue, pixel/2 + 128, pixel);
|
Chris@77
|
1002 m_crosshairColour = QColor(255, 150, 50);
|
Chris@77
|
1003 // m_crosshairColour = QColor::fromHsv(240, 160, 255);
|
Chris@0
|
1004 break;
|
Chris@0
|
1005
|
Chris@0
|
1006 case WhiteOnBlack:
|
Chris@0
|
1007 colour = QColor(pixel, pixel, pixel);
|
Chris@77
|
1008 m_crosshairColour = Qt::red;
|
Chris@0
|
1009 break;
|
Chris@0
|
1010
|
Chris@0
|
1011 case BlackOnWhite:
|
Chris@0
|
1012 colour = QColor(256-pixel, 256-pixel, 256-pixel);
|
Chris@77
|
1013 m_crosshairColour = Qt::darkGreen;
|
Chris@0
|
1014 break;
|
Chris@0
|
1015
|
Chris@0
|
1016 case RedOnBlue:
|
Chris@0
|
1017 colour = QColor(pixel > 128 ? (pixel - 128) * 2 : 0, 0,
|
Chris@0
|
1018 pixel < 128 ? pixel : (256 - pixel));
|
Chris@77
|
1019 m_crosshairColour = Qt::green;
|
Chris@0
|
1020 break;
|
Chris@0
|
1021
|
Chris@0
|
1022 case YellowOnBlack:
|
Chris@0
|
1023 px = 256 - pixel;
|
Chris@0
|
1024 colour = QColor(px < 64 ? 255 - px/2 :
|
Chris@0
|
1025 px < 128 ? 224 - (px - 64) :
|
Chris@0
|
1026 px < 192 ? 160 - (px - 128) * 3 / 2 :
|
Chris@0
|
1027 256 - px,
|
Chris@0
|
1028 pixel,
|
Chris@0
|
1029 pixel / 4);
|
Chris@77
|
1030 m_crosshairColour = QColor::fromHsv(240, 255, 255);
|
Chris@0
|
1031 break;
|
Chris@0
|
1032
|
Chris@71
|
1033 case BlueOnBlack:
|
Chris@71
|
1034 colour = QColor::fromHsv
|
Chris@71
|
1035 (240, pixel > 226 ? 256 - (pixel - 226) * 8 : 255,
|
Chris@71
|
1036 (pixel * pixel) / 255);
|
Chris@77
|
1037 m_crosshairColour = Qt::red;
|
Chris@71
|
1038 break;
|
Chris@71
|
1039
|
Chris@40
|
1040 case Rainbow:
|
Chris@40
|
1041 hue = 250 - pixel;
|
Chris@40
|
1042 if (hue < 0) hue += 256;
|
Chris@40
|
1043 colour = QColor::fromHsv(pixel, 255, 255);
|
Chris@77
|
1044 m_crosshairColour = Qt::white;
|
Chris@0
|
1045 break;
|
Chris@0
|
1046 }
|
Chris@0
|
1047
|
Chris@86
|
1048 m_colourMap.setColour(pixel, colour);
|
Chris@0
|
1049 }
|
Chris@9
|
1050
|
Chris@9
|
1051 m_colourRotation = 0;
|
Chris@90
|
1052 rotateColourmap(m_colourRotation - formerRotation);
|
Chris@10
|
1053 m_colourRotation = formerRotation;
|
Chris@9
|
1054 }
|
Chris@9
|
1055
|
Chris@9
|
1056 void
|
Chris@90
|
1057 SpectrogramLayer::rotateColourmap(int distance)
|
Chris@9
|
1058 {
|
Chris@31
|
1059 QColor newPixels[256];
|
Chris@9
|
1060
|
Chris@86
|
1061 newPixels[NO_VALUE] = m_colourMap.getColour(NO_VALUE);
|
Chris@9
|
1062
|
Chris@9
|
1063 for (int pixel = 1; pixel < 256; ++pixel) {
|
Chris@9
|
1064 int target = pixel + distance;
|
Chris@9
|
1065 while (target < 1) target += 255;
|
Chris@9
|
1066 while (target > 255) target -= 255;
|
Chris@86
|
1067 newPixels[target] = m_colourMap.getColour(pixel);
|
Chris@9
|
1068 }
|
Chris@9
|
1069
|
Chris@9
|
1070 for (int pixel = 0; pixel < 256; ++pixel) {
|
Chris@86
|
1071 m_colourMap.setColour(pixel, newPixels[pixel]);
|
Chris@9
|
1072 }
|
Chris@0
|
1073 }
|
Chris@0
|
1074
|
Chris@38
|
1075 float
|
Chris@38
|
1076 SpectrogramLayer::calculateFrequency(size_t bin,
|
Chris@38
|
1077 size_t windowSize,
|
Chris@38
|
1078 size_t windowIncrement,
|
Chris@38
|
1079 size_t sampleRate,
|
Chris@38
|
1080 float oldPhase,
|
Chris@38
|
1081 float newPhase,
|
Chris@38
|
1082 bool &steadyState)
|
Chris@38
|
1083 {
|
Chris@38
|
1084 // At frequency f, phase shift of 2pi (one cycle) happens in 1/f sec.
|
Chris@38
|
1085 // At hopsize h and sample rate sr, one hop happens in h/sr sec.
|
Chris@38
|
1086 // At window size w, for bin b, f is b*sr/w.
|
Chris@38
|
1087 // thus 2pi phase shift happens in w/(b*sr) sec.
|
Chris@38
|
1088 // We need to know what phase shift we expect from h/sr sec.
|
Chris@38
|
1089 // -> 2pi * ((h/sr) / (w/(b*sr)))
|
Chris@38
|
1090 // = 2pi * ((h * b * sr) / (w * sr))
|
Chris@38
|
1091 // = 2pi * (h * b) / w.
|
Chris@38
|
1092
|
Chris@38
|
1093 float frequency = (float(bin) * sampleRate) / windowSize;
|
Chris@38
|
1094
|
Chris@38
|
1095 float expectedPhase =
|
Chris@38
|
1096 oldPhase + (2.0 * M_PI * bin * windowIncrement) / windowSize;
|
Chris@38
|
1097
|
Chris@104
|
1098 float phaseError = princargf(newPhase - expectedPhase);
|
Chris@38
|
1099
|
Chris@38
|
1100 if (fabs(phaseError) < (1.1 * (windowIncrement * M_PI) / windowSize)) {
|
Chris@38
|
1101
|
Chris@38
|
1102 // The new frequency estimate based on the phase error
|
Chris@38
|
1103 // resulting from assuming the "native" frequency of this bin
|
Chris@38
|
1104
|
Chris@38
|
1105 float newFrequency =
|
Chris@38
|
1106 (sampleRate * (expectedPhase + phaseError - oldPhase)) /
|
Chris@38
|
1107 (2 * M_PI * windowIncrement);
|
Chris@38
|
1108
|
Chris@38
|
1109 steadyState = true;
|
Chris@38
|
1110 return newFrequency;
|
Chris@38
|
1111 }
|
Chris@38
|
1112
|
Chris@38
|
1113 steadyState = false;
|
Chris@38
|
1114 return frequency;
|
Chris@38
|
1115 }
|
Chris@38
|
1116
|
Chris@38
|
1117 unsigned char
|
Chris@119
|
1118 SpectrogramLayer::getDisplayValue(View *v, float input) const
|
Chris@38
|
1119 {
|
Chris@38
|
1120 int value;
|
Chris@37
|
1121
|
Chris@120
|
1122 float min = 0.f;
|
Chris@120
|
1123 float max = 1.f;
|
Chris@120
|
1124
|
Chris@120
|
1125 if (m_normalizeVisibleArea) {
|
Chris@120
|
1126 min = m_viewMags[v].getMin();
|
Chris@120
|
1127 max = m_viewMags[v].getMax();
|
Chris@120
|
1128 } else if (!m_normalizeColumns) {
|
Chris@120
|
1129 if (m_colourScale == LinearColourScale ||
|
Chris@120
|
1130 m_colourScale == MeterColourScale) {
|
Chris@120
|
1131 max = 0.1f;
|
Chris@120
|
1132 }
|
Chris@120
|
1133 }
|
Chris@120
|
1134
|
Chris@119
|
1135 float thresh = -80.f;
|
Chris@119
|
1136
|
Chris@119
|
1137 if (max == 0.f) max = 1.f;
|
Chris@119
|
1138 if (max == min) min = max - 0.0001f;
|
Chris@119
|
1139
|
Chris@40
|
1140 switch (m_colourScale) {
|
Chris@40
|
1141
|
Chris@40
|
1142 default:
|
Chris@40
|
1143 case LinearColourScale:
|
Chris@119
|
1144 // value = int
|
Chris@119
|
1145 // (input * (m_normalizeColumns ? 1.0 : 50.0) * 255.0) + 1;
|
Chris@119
|
1146 value = int(((input - min) / (max - min)) * 255.f) + 1;
|
Chris@40
|
1147 break;
|
Chris@40
|
1148
|
Chris@40
|
1149 case MeterColourScale:
|
Chris@119
|
1150 // value = AudioLevel::multiplier_to_preview
|
Chris@119
|
1151 // (input * (m_normalizeColumns ? 1.0 : 50.0), 255) + 1;
|
Chris@119
|
1152 value = AudioLevel::multiplier_to_preview((input - min) / (max - min), 255) + 1;
|
Chris@40
|
1153 break;
|
Chris@40
|
1154
|
Chris@40
|
1155 case dBColourScale:
|
Chris@119
|
1156 //!!! experiment with normalizing the visible area this way.
|
Chris@119
|
1157 //In any case, we need to have some indication of what the dB
|
Chris@119
|
1158 //scale is relative to.
|
Chris@119
|
1159 input = 10.f * log10f(input / max);
|
Chris@119
|
1160 if (min > 0.f) {
|
Chris@119
|
1161 thresh = 10.f * log10f(min);
|
Chris@119
|
1162 if (thresh < -80.f) thresh = -80.f;
|
Chris@119
|
1163 }
|
Chris@119
|
1164 input = (input - thresh) / (-thresh);
|
Chris@119
|
1165 if (input < 0.f) input = 0.f;
|
Chris@119
|
1166 if (input > 1.f) input = 1.f;
|
Chris@119
|
1167 value = int(input * 255.f) + 1;
|
Chris@119
|
1168 break;
|
Chris@119
|
1169
|
Chris@119
|
1170 case OtherColourScale:
|
Chris@119
|
1171 //!!! the "Other" scale is just where our current experiments go
|
Chris@119
|
1172 //!!! power rather than v
|
Chris@119
|
1173 input = 10.f * log10f((input * input) / (max * max));
|
Chris@119
|
1174 if (min > 0.f) {
|
Chris@119
|
1175 thresh = 10.f * log10f(min * min);
|
Chris@119
|
1176 if (thresh < -80.f) thresh = -80.f;
|
Chris@119
|
1177 }
|
Chris@119
|
1178 input = (input - thresh) / (-thresh);
|
Chris@119
|
1179 if (input < 0.f) input = 0.f;
|
Chris@119
|
1180 if (input > 1.f) input = 1.f;
|
Chris@119
|
1181 value = int(input * 255.f) + 1;
|
Chris@119
|
1182 break;
|
Chris@119
|
1183
|
Chris@119
|
1184 /*!!!
|
Chris@119
|
1185 input = 10.f * log10f(input * input);
|
Chris@119
|
1186 input = 1.f / (1.f + expf(- (input + 20.f) / 10.f));
|
Chris@119
|
1187
|
Chris@119
|
1188 if (input < 0.f) input = 0.f;
|
Chris@119
|
1189 if (input > 1.f) input = 1.f;
|
Chris@119
|
1190 value = int(input * 255.f) + 1;
|
Chris@119
|
1191 */
|
Chris@40
|
1192 break;
|
Chris@40
|
1193
|
Chris@40
|
1194 case PhaseColourScale:
|
Chris@40
|
1195 value = int((input * 127.0 / M_PI) + 128);
|
Chris@40
|
1196 break;
|
Chris@0
|
1197 }
|
Chris@38
|
1198
|
Chris@38
|
1199 if (value > UCHAR_MAX) value = UCHAR_MAX;
|
Chris@38
|
1200 if (value < 0) value = 0;
|
Chris@38
|
1201 return value;
|
Chris@0
|
1202 }
|
Chris@0
|
1203
|
Chris@40
|
1204 float
|
Chris@40
|
1205 SpectrogramLayer::getInputForDisplayValue(unsigned char uc) const
|
Chris@40
|
1206 {
|
Chris@40
|
1207 int value = uc;
|
Chris@40
|
1208 float input;
|
Chris@40
|
1209
|
Chris@120
|
1210 //!!! incorrect for normalizing visible area (and also out of date)
|
Chris@120
|
1211
|
Chris@40
|
1212 switch (m_colourScale) {
|
Chris@40
|
1213
|
Chris@40
|
1214 default:
|
Chris@40
|
1215 case LinearColourScale:
|
Chris@40
|
1216 input = float(value - 1) / 255.0 / (m_normalizeColumns ? 1 : 50);
|
Chris@40
|
1217 break;
|
Chris@40
|
1218
|
Chris@40
|
1219 case MeterColourScale:
|
Chris@40
|
1220 input = AudioLevel::preview_to_multiplier(value - 1, 255)
|
Chris@40
|
1221 / (m_normalizeColumns ? 1.0 : 50.0);
|
Chris@40
|
1222 break;
|
Chris@40
|
1223
|
Chris@40
|
1224 case dBColourScale:
|
Chris@40
|
1225 input = float(value - 1) / 255.0;
|
Chris@40
|
1226 input = (input * 80.0) - 80.0;
|
Chris@40
|
1227 input = powf(10.0, input) / 20.0;
|
Chris@40
|
1228 value = int(input);
|
Chris@40
|
1229 break;
|
Chris@40
|
1230
|
Chris@119
|
1231 case OtherColourScale:
|
Chris@119
|
1232 input = float(value - 1) / 255.0;
|
Chris@119
|
1233 input = (input * 80.0) - 80.0;
|
Chris@119
|
1234 input = powf(10.0, input) / 20.0;
|
Chris@119
|
1235 value = int(input);
|
Chris@119
|
1236 break;
|
Chris@119
|
1237
|
Chris@40
|
1238 case PhaseColourScale:
|
Chris@40
|
1239 input = float(value - 128) * M_PI / 127.0;
|
Chris@40
|
1240 break;
|
Chris@40
|
1241 }
|
Chris@40
|
1242
|
Chris@40
|
1243 return input;
|
Chris@40
|
1244 }
|
Chris@40
|
1245
|
Chris@40
|
1246 float
|
Chris@40
|
1247 SpectrogramLayer::getEffectiveMinFrequency() const
|
Chris@40
|
1248 {
|
Chris@40
|
1249 int sr = m_model->getSampleRate();
|
Chris@107
|
1250 float minf = float(sr) / m_fftSize;
|
Chris@40
|
1251
|
Chris@40
|
1252 if (m_minFrequency > 0.0) {
|
Chris@107
|
1253 size_t minbin = size_t((double(m_minFrequency) * m_fftSize) / sr + 0.01);
|
Chris@40
|
1254 if (minbin < 1) minbin = 1;
|
Chris@107
|
1255 minf = minbin * sr / m_fftSize;
|
Chris@40
|
1256 }
|
Chris@40
|
1257
|
Chris@40
|
1258 return minf;
|
Chris@40
|
1259 }
|
Chris@40
|
1260
|
Chris@40
|
1261 float
|
Chris@40
|
1262 SpectrogramLayer::getEffectiveMaxFrequency() const
|
Chris@40
|
1263 {
|
Chris@40
|
1264 int sr = m_model->getSampleRate();
|
Chris@40
|
1265 float maxf = float(sr) / 2;
|
Chris@40
|
1266
|
Chris@40
|
1267 if (m_maxFrequency > 0.0) {
|
Chris@107
|
1268 size_t maxbin = size_t((double(m_maxFrequency) * m_fftSize) / sr + 0.1);
|
Chris@107
|
1269 if (maxbin > m_fftSize / 2) maxbin = m_fftSize / 2;
|
Chris@107
|
1270 maxf = maxbin * sr / m_fftSize;
|
Chris@40
|
1271 }
|
Chris@40
|
1272
|
Chris@40
|
1273 return maxf;
|
Chris@40
|
1274 }
|
Chris@40
|
1275
|
Chris@0
|
1276 bool
|
Chris@44
|
1277 SpectrogramLayer::getYBinRange(View *v, int y, float &q0, float &q1) const
|
Chris@0
|
1278 {
|
Chris@44
|
1279 int h = v->height();
|
Chris@0
|
1280 if (y < 0 || y >= h) return false;
|
Chris@0
|
1281
|
Chris@38
|
1282 int sr = m_model->getSampleRate();
|
Chris@40
|
1283 float minf = getEffectiveMinFrequency();
|
Chris@40
|
1284 float maxf = getEffectiveMaxFrequency();
|
Chris@0
|
1285
|
Chris@38
|
1286 bool logarithmic = (m_frequencyScale == LogFrequencyScale);
|
Chris@38
|
1287
|
Chris@130
|
1288 //!!! wrong for smoothing -- wrong fft size for fft model
|
Chris@114
|
1289
|
Chris@44
|
1290 q0 = v->getFrequencyForY(y, minf, maxf, logarithmic);
|
Chris@44
|
1291 q1 = v->getFrequencyForY(y - 1, minf, maxf, logarithmic);
|
Chris@38
|
1292
|
Chris@38
|
1293 // Now map these on to actual bins
|
Chris@38
|
1294
|
Chris@107
|
1295 int b0 = int((q0 * m_fftSize) / sr);
|
Chris@107
|
1296 int b1 = int((q1 * m_fftSize) / sr);
|
Chris@0
|
1297
|
Chris@40
|
1298 //!!! this is supposed to return fractions-of-bins, as it were, hence the floats
|
Chris@38
|
1299 q0 = b0;
|
Chris@38
|
1300 q1 = b1;
|
Chris@38
|
1301
|
Chris@107
|
1302 // q0 = (b0 * sr) / m_fftSize;
|
Chris@107
|
1303 // q1 = (b1 * sr) / m_fftSize;
|
Chris@0
|
1304
|
Chris@0
|
1305 return true;
|
Chris@0
|
1306 }
|
Chris@38
|
1307
|
Chris@0
|
1308 bool
|
Chris@44
|
1309 SpectrogramLayer::getXBinRange(View *v, int x, float &s0, float &s1) const
|
Chris@0
|
1310 {
|
Chris@21
|
1311 size_t modelStart = m_model->getStartFrame();
|
Chris@21
|
1312 size_t modelEnd = m_model->getEndFrame();
|
Chris@0
|
1313
|
Chris@0
|
1314 // Each pixel column covers an exact range of sample frames:
|
Chris@44
|
1315 int f0 = v->getFrameForX(x) - modelStart;
|
Chris@44
|
1316 int f1 = v->getFrameForX(x + 1) - modelStart - 1;
|
Chris@20
|
1317
|
Chris@41
|
1318 if (f1 < int(modelStart) || f0 > int(modelEnd)) {
|
Chris@41
|
1319 return false;
|
Chris@41
|
1320 }
|
Chris@20
|
1321
|
Chris@0
|
1322 // And that range may be drawn from a possibly non-integral
|
Chris@0
|
1323 // range of spectrogram windows:
|
Chris@0
|
1324
|
Chris@0
|
1325 size_t windowIncrement = getWindowIncrement();
|
Chris@0
|
1326 s0 = float(f0) / windowIncrement;
|
Chris@0
|
1327 s1 = float(f1) / windowIncrement;
|
Chris@0
|
1328
|
Chris@0
|
1329 return true;
|
Chris@0
|
1330 }
|
Chris@0
|
1331
|
Chris@0
|
1332 bool
|
Chris@44
|
1333 SpectrogramLayer::getXBinSourceRange(View *v, int x, RealTime &min, RealTime &max) const
|
Chris@0
|
1334 {
|
Chris@0
|
1335 float s0 = 0, s1 = 0;
|
Chris@44
|
1336 if (!getXBinRange(v, x, s0, s1)) return false;
|
Chris@0
|
1337
|
Chris@0
|
1338 int s0i = int(s0 + 0.001);
|
Chris@0
|
1339 int s1i = int(s1);
|
Chris@0
|
1340
|
Chris@0
|
1341 int windowIncrement = getWindowIncrement();
|
Chris@0
|
1342 int w0 = s0i * windowIncrement - (m_windowSize - windowIncrement)/2;
|
Chris@0
|
1343 int w1 = s1i * windowIncrement + windowIncrement +
|
Chris@0
|
1344 (m_windowSize - windowIncrement)/2 - 1;
|
Chris@0
|
1345
|
Chris@0
|
1346 min = RealTime::frame2RealTime(w0, m_model->getSampleRate());
|
Chris@0
|
1347 max = RealTime::frame2RealTime(w1, m_model->getSampleRate());
|
Chris@0
|
1348 return true;
|
Chris@0
|
1349 }
|
Chris@0
|
1350
|
Chris@0
|
1351 bool
|
Chris@44
|
1352 SpectrogramLayer::getYBinSourceRange(View *v, int y, float &freqMin, float &freqMax)
|
Chris@0
|
1353 const
|
Chris@0
|
1354 {
|
Chris@0
|
1355 float q0 = 0, q1 = 0;
|
Chris@44
|
1356 if (!getYBinRange(v, y, q0, q1)) return false;
|
Chris@0
|
1357
|
Chris@0
|
1358 int q0i = int(q0 + 0.001);
|
Chris@0
|
1359 int q1i = int(q1);
|
Chris@0
|
1360
|
Chris@0
|
1361 int sr = m_model->getSampleRate();
|
Chris@0
|
1362
|
Chris@0
|
1363 for (int q = q0i; q <= q1i; ++q) {
|
Chris@121
|
1364 if (q == q0i) freqMin = (sr * q) / m_fftSize;
|
Chris@121
|
1365 if (q == q1i) freqMax = (sr * (q+1)) / m_fftSize;
|
Chris@0
|
1366 }
|
Chris@0
|
1367 return true;
|
Chris@0
|
1368 }
|
Chris@35
|
1369
|
Chris@35
|
1370 bool
|
Chris@44
|
1371 SpectrogramLayer::getAdjustedYBinSourceRange(View *v, int x, int y,
|
Chris@35
|
1372 float &freqMin, float &freqMax,
|
Chris@35
|
1373 float &adjFreqMin, float &adjFreqMax)
|
Chris@35
|
1374 const
|
Chris@35
|
1375 {
|
Chris@130
|
1376 FFTModel *fft = getFFTModel(v);
|
Chris@114
|
1377 if (!fft) return false;
|
Chris@110
|
1378
|
Chris@35
|
1379 float s0 = 0, s1 = 0;
|
Chris@44
|
1380 if (!getXBinRange(v, x, s0, s1)) return false;
|
Chris@35
|
1381
|
Chris@35
|
1382 float q0 = 0, q1 = 0;
|
Chris@44
|
1383 if (!getYBinRange(v, y, q0, q1)) return false;
|
Chris@35
|
1384
|
Chris@35
|
1385 int s0i = int(s0 + 0.001);
|
Chris@35
|
1386 int s1i = int(s1);
|
Chris@35
|
1387
|
Chris@35
|
1388 int q0i = int(q0 + 0.001);
|
Chris@35
|
1389 int q1i = int(q1);
|
Chris@35
|
1390
|
Chris@35
|
1391 int sr = m_model->getSampleRate();
|
Chris@35
|
1392
|
Chris@38
|
1393 size_t windowSize = m_windowSize;
|
Chris@38
|
1394 size_t windowIncrement = getWindowIncrement();
|
Chris@38
|
1395
|
Chris@35
|
1396 bool haveAdj = false;
|
Chris@35
|
1397
|
Chris@37
|
1398 bool peaksOnly = (m_binDisplay == PeakBins ||
|
Chris@37
|
1399 m_binDisplay == PeakFrequencies);
|
Chris@37
|
1400
|
Chris@35
|
1401 for (int q = q0i; q <= q1i; ++q) {
|
Chris@35
|
1402
|
Chris@35
|
1403 for (int s = s0i; s <= s1i; ++s) {
|
Chris@35
|
1404
|
Chris@117
|
1405 if (!fft->isColumnReady(s)) continue;
|
Chris@117
|
1406
|
Chris@35
|
1407 float binfreq = (sr * q) / m_windowSize;
|
Chris@35
|
1408 if (q == q0i) freqMin = binfreq;
|
Chris@35
|
1409 if (q == q1i) freqMax = binfreq;
|
Chris@37
|
1410
|
Chris@114
|
1411 if (peaksOnly && !fft->isLocalPeak(s, q)) continue;
|
Chris@38
|
1412
|
Chris@114
|
1413 if (!fft->isOverThreshold(s, q, m_threshold)) continue;
|
Chris@38
|
1414
|
Chris@38
|
1415 float freq = binfreq;
|
Chris@38
|
1416 bool steady = false;
|
Chris@40
|
1417
|
Chris@114
|
1418 if (s < int(fft->getWidth()) - 1) {
|
Chris@38
|
1419
|
Chris@38
|
1420 freq = calculateFrequency(q,
|
Chris@38
|
1421 windowSize,
|
Chris@38
|
1422 windowIncrement,
|
Chris@38
|
1423 sr,
|
Chris@114
|
1424 fft->getPhaseAt(s, q),
|
Chris@114
|
1425 fft->getPhaseAt(s+1, q),
|
Chris@38
|
1426 steady);
|
Chris@35
|
1427
|
Chris@38
|
1428 if (!haveAdj || freq < adjFreqMin) adjFreqMin = freq;
|
Chris@38
|
1429 if (!haveAdj || freq > adjFreqMax) adjFreqMax = freq;
|
Chris@35
|
1430
|
Chris@35
|
1431 haveAdj = true;
|
Chris@35
|
1432 }
|
Chris@35
|
1433 }
|
Chris@35
|
1434 }
|
Chris@35
|
1435
|
Chris@35
|
1436 if (!haveAdj) {
|
Chris@40
|
1437 adjFreqMin = adjFreqMax = 0.0;
|
Chris@35
|
1438 }
|
Chris@35
|
1439
|
Chris@35
|
1440 return haveAdj;
|
Chris@35
|
1441 }
|
Chris@0
|
1442
|
Chris@0
|
1443 bool
|
Chris@44
|
1444 SpectrogramLayer::getXYBinSourceRange(View *v, int x, int y,
|
Chris@38
|
1445 float &min, float &max,
|
Chris@38
|
1446 float &phaseMin, float &phaseMax) const
|
Chris@0
|
1447 {
|
Chris@0
|
1448 float q0 = 0, q1 = 0;
|
Chris@44
|
1449 if (!getYBinRange(v, y, q0, q1)) return false;
|
Chris@0
|
1450
|
Chris@0
|
1451 float s0 = 0, s1 = 0;
|
Chris@44
|
1452 if (!getXBinRange(v, x, s0, s1)) return false;
|
Chris@0
|
1453
|
Chris@0
|
1454 int q0i = int(q0 + 0.001);
|
Chris@0
|
1455 int q1i = int(q1);
|
Chris@0
|
1456
|
Chris@0
|
1457 int s0i = int(s0 + 0.001);
|
Chris@0
|
1458 int s1i = int(s1);
|
Chris@0
|
1459
|
Chris@37
|
1460 bool rv = false;
|
Chris@37
|
1461
|
Chris@122
|
1462 size_t zp = getZeroPadLevel(v);
|
Chris@122
|
1463 q0i *= zp + 1;
|
Chris@122
|
1464 q1i *= zp + 1;
|
Chris@122
|
1465
|
Chris@130
|
1466 FFTModel *fft = getFFTModel(v);
|
Chris@0
|
1467
|
Chris@114
|
1468 if (fft) {
|
Chris@114
|
1469
|
Chris@114
|
1470 int cw = fft->getWidth();
|
Chris@114
|
1471 int ch = fft->getHeight();
|
Chris@0
|
1472
|
Chris@110
|
1473 min = 0.0;
|
Chris@110
|
1474 max = 0.0;
|
Chris@110
|
1475 phaseMin = 0.0;
|
Chris@110
|
1476 phaseMax = 0.0;
|
Chris@110
|
1477 bool have = false;
|
Chris@0
|
1478
|
Chris@110
|
1479 for (int q = q0i; q <= q1i; ++q) {
|
Chris@110
|
1480 for (int s = s0i; s <= s1i; ++s) {
|
Chris@110
|
1481 if (s >= 0 && q >= 0 && s < cw && q < ch) {
|
Chris@117
|
1482
|
Chris@117
|
1483 if (!fft->isColumnReady(s)) continue;
|
Chris@110
|
1484
|
Chris@110
|
1485 float value;
|
Chris@38
|
1486
|
Chris@114
|
1487 value = fft->getPhaseAt(s, q);
|
Chris@110
|
1488 if (!have || value < phaseMin) { phaseMin = value; }
|
Chris@110
|
1489 if (!have || value > phaseMax) { phaseMax = value; }
|
Chris@91
|
1490
|
Chris@114
|
1491 value = fft->getMagnitudeAt(s, q);
|
Chris@110
|
1492 if (!have || value < min) { min = value; }
|
Chris@110
|
1493 if (!have || value > max) { max = value; }
|
Chris@110
|
1494
|
Chris@110
|
1495 have = true;
|
Chris@110
|
1496 }
|
Chris@110
|
1497 }
|
Chris@110
|
1498 }
|
Chris@110
|
1499
|
Chris@110
|
1500 if (have) {
|
Chris@110
|
1501 rv = true;
|
Chris@110
|
1502 }
|
Chris@0
|
1503 }
|
Chris@0
|
1504
|
Chris@37
|
1505 return rv;
|
Chris@0
|
1506 }
|
Chris@0
|
1507
|
Chris@114
|
1508 size_t
|
Chris@114
|
1509 SpectrogramLayer::getZeroPadLevel(const View *v) const
|
Chris@114
|
1510 {
|
Chris@114
|
1511 //!!! tidy all this stuff
|
Chris@114
|
1512
|
Chris@114
|
1513 if (m_binDisplay != AllBins) return 0;
|
Chris@118
|
1514 if (!Preferences::getInstance()->getSmoothSpectrogram()) return 0;
|
Chris@114
|
1515 if (m_frequencyScale == LogFrequencyScale) return 3;
|
Chris@114
|
1516
|
Chris@114
|
1517 int sr = m_model->getSampleRate();
|
Chris@114
|
1518
|
Chris@114
|
1519 size_t bins = m_fftSize / 2;
|
Chris@114
|
1520 if (m_maxFrequency > 0) {
|
Chris@114
|
1521 bins = int((double(m_maxFrequency) * m_fftSize) / sr + 0.1);
|
Chris@114
|
1522 if (bins > m_fftSize / 2) bins = m_fftSize / 2;
|
Chris@114
|
1523 }
|
Chris@114
|
1524
|
Chris@114
|
1525 size_t minbin = 1;
|
Chris@114
|
1526 if (m_minFrequency > 0) {
|
Chris@114
|
1527 minbin = int((double(m_minFrequency) * m_fftSize) / sr + 0.1);
|
Chris@114
|
1528 if (minbin < 1) minbin = 1;
|
Chris@114
|
1529 if (minbin >= bins) minbin = bins - 1;
|
Chris@114
|
1530 }
|
Chris@114
|
1531
|
Chris@118
|
1532 float perPixel =
|
Chris@118
|
1533 float(v->height()) /
|
Chris@118
|
1534 float((bins - minbin) / (m_zeroPadLevel + 1));
|
Chris@118
|
1535
|
Chris@118
|
1536 if (perPixel > 2.8) {
|
Chris@118
|
1537 return 3; // 4x oversampling
|
Chris@118
|
1538 } else if (perPixel > 1.5) {
|
Chris@118
|
1539 return 1; // 2x
|
Chris@114
|
1540 } else {
|
Chris@118
|
1541 return 0; // 1x
|
Chris@114
|
1542 }
|
Chris@114
|
1543 }
|
Chris@114
|
1544
|
Chris@114
|
1545 size_t
|
Chris@114
|
1546 SpectrogramLayer::getFFTSize(const View *v) const
|
Chris@114
|
1547 {
|
Chris@114
|
1548 return m_fftSize * (getZeroPadLevel(v) + 1);
|
Chris@114
|
1549 }
|
Chris@114
|
1550
|
Chris@130
|
1551 FFTModel *
|
Chris@130
|
1552 SpectrogramLayer::getFFTModel(const View *v) const
|
Chris@114
|
1553 {
|
Chris@114
|
1554 if (!m_model) return 0;
|
Chris@114
|
1555
|
Chris@114
|
1556 size_t fftSize = getFFTSize(v);
|
Chris@114
|
1557
|
Chris@130
|
1558 if (m_fftModels.find(v) != m_fftModels.end()) {
|
Chris@130
|
1559 if (m_fftModels[v].first->getHeight() != fftSize / 2) {
|
Chris@130
|
1560 delete m_fftModels[v].first;
|
Chris@130
|
1561 m_fftModels.erase(v);
|
Chris@114
|
1562 }
|
Chris@114
|
1563 }
|
Chris@114
|
1564
|
Chris@130
|
1565 if (m_fftModels.find(v) == m_fftModels.end()) {
|
Chris@130
|
1566 m_fftModels[v] = FFTFillPair
|
Chris@130
|
1567 (new FFTModel(m_model,
|
Chris@115
|
1568 m_channel,
|
Chris@115
|
1569 m_windowType,
|
Chris@115
|
1570 m_windowSize,
|
Chris@115
|
1571 getWindowIncrement(),
|
Chris@121
|
1572 fftSize,
|
Chris@115
|
1573 true,
|
Chris@115
|
1574 m_candidateFillStartFrame),
|
Chris@115
|
1575 0);
|
Chris@114
|
1576
|
Chris@114
|
1577 delete m_updateTimer;
|
Chris@114
|
1578 m_updateTimer = new QTimer((SpectrogramLayer *)this);
|
Chris@114
|
1579 connect(m_updateTimer, SIGNAL(timeout()),
|
Chris@114
|
1580 this, SLOT(fillTimerTimedOut()));
|
Chris@114
|
1581 m_updateTimer->start(200);
|
Chris@114
|
1582 }
|
Chris@114
|
1583
|
Chris@130
|
1584 return m_fftModels[v].first;
|
Chris@114
|
1585 }
|
Chris@114
|
1586
|
Chris@114
|
1587 void
|
Chris@130
|
1588 SpectrogramLayer::invalidateFFTModels()
|
Chris@114
|
1589 {
|
Chris@130
|
1590 for (ViewFFTMap::iterator i = m_fftModels.begin();
|
Chris@130
|
1591 i != m_fftModels.end(); ++i) {
|
Chris@115
|
1592 delete i->second.first;
|
Chris@114
|
1593 }
|
Chris@114
|
1594
|
Chris@130
|
1595 m_fftModels.clear();
|
Chris@114
|
1596 }
|
Chris@114
|
1597
|
Chris@0
|
1598 void
|
Chris@119
|
1599 SpectrogramLayer::invalidateMagnitudes()
|
Chris@119
|
1600 {
|
Chris@119
|
1601 m_viewMags.clear();
|
Chris@119
|
1602 for (std::vector<MagnitudeRange>::iterator i = m_columnMags.begin();
|
Chris@119
|
1603 i != m_columnMags.end(); ++i) {
|
Chris@119
|
1604 *i = MagnitudeRange();
|
Chris@119
|
1605 }
|
Chris@119
|
1606 }
|
Chris@119
|
1607
|
Chris@119
|
1608 bool
|
Chris@119
|
1609 SpectrogramLayer::updateViewMagnitudes(View *v) const
|
Chris@119
|
1610 {
|
Chris@119
|
1611 MagnitudeRange mag;
|
Chris@119
|
1612
|
Chris@119
|
1613 int x0 = 0, x1 = v->width();
|
Chris@119
|
1614 float s00 = 0, s01 = 0, s10 = 0, s11 = 0;
|
Chris@119
|
1615
|
Chris@119
|
1616 getXBinRange(v, x0, s00, s01);
|
Chris@119
|
1617 getXBinRange(v, x1, s10, s11);
|
Chris@119
|
1618
|
Chris@119
|
1619 int s0 = int(std::min(s00, s10) + 0.0001);
|
Chris@119
|
1620 int s1 = int(std::max(s01, s11));
|
Chris@119
|
1621
|
Chris@119
|
1622 if (m_columnMags.size() <= s1) {
|
Chris@119
|
1623 m_columnMags.resize(s1 + 1);
|
Chris@119
|
1624 }
|
Chris@119
|
1625
|
Chris@119
|
1626 for (int s = s0; s <= s1; ++s) {
|
Chris@119
|
1627 if (m_columnMags[s].isSet()) {
|
Chris@119
|
1628 mag.sample(m_columnMags[s]);
|
Chris@119
|
1629 }
|
Chris@119
|
1630 }
|
Chris@119
|
1631
|
Chris@119
|
1632 std::cerr << "SpectrogramLayer::updateViewMagnitudes returning from cols "
|
Chris@119
|
1633 << s0 << " -> " << s1 << " inclusive" << std::endl;
|
Chris@119
|
1634
|
Chris@119
|
1635 if (!mag.isSet()) return false;
|
Chris@119
|
1636 if (mag == m_viewMags[v]) return false;
|
Chris@119
|
1637 m_viewMags[v] = mag;
|
Chris@119
|
1638 return true;
|
Chris@119
|
1639 }
|
Chris@119
|
1640
|
Chris@119
|
1641 void
|
Chris@44
|
1642 SpectrogramLayer::paint(View *v, QPainter &paint, QRect rect) const
|
Chris@0
|
1643 {
|
Chris@55
|
1644 if (m_colourScheme == BlackOnWhite) {
|
Chris@55
|
1645 v->setLightBackground(true);
|
Chris@55
|
1646 } else {
|
Chris@55
|
1647 v->setLightBackground(false);
|
Chris@55
|
1648 }
|
Chris@55
|
1649
|
Chris@124
|
1650 // Profiler profiler("SpectrogramLayer::paint", true);
|
Chris@0
|
1651 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@95
|
1652 std::cerr << "SpectrogramLayer::paint(): m_model is " << m_model << ", zoom level is " << v->getZoomLevel() << ", m_updateTimer " << m_updateTimer << std::endl;
|
Chris@95
|
1653
|
Chris@95
|
1654 std::cerr << "rect is " << rect.x() << "," << rect.y() << " " << rect.width() << "x" << rect.height() << std::endl;
|
Chris@0
|
1655 #endif
|
Chris@95
|
1656
|
Chris@45
|
1657 long sf = v->getStartFrame();
|
Chris@45
|
1658 if (sf < 0) m_candidateFillStartFrame = 0;
|
Chris@45
|
1659 else m_candidateFillStartFrame = sf;
|
Chris@44
|
1660
|
Chris@0
|
1661 if (!m_model || !m_model->isOK() || !m_model->isReady()) {
|
Chris@0
|
1662 return;
|
Chris@0
|
1663 }
|
Chris@0
|
1664
|
Chris@47
|
1665 if (isLayerDormant(v)) {
|
Chris@48
|
1666 std::cerr << "SpectrogramLayer::paint(): Layer is dormant, making it undormant again" << std::endl;
|
Chris@29
|
1667 }
|
Chris@29
|
1668
|
Chris@48
|
1669 // Need to do this even if !isLayerDormant, as that could mean v
|
Chris@48
|
1670 // is not in the dormancy map at all -- we need it to be present
|
Chris@48
|
1671 // and accountable for when determining whether we need the cache
|
Chris@48
|
1672 // in the cache-fill thread above.
|
Chris@48
|
1673 m_dormancy[v] = false;
|
Chris@48
|
1674
|
Chris@114
|
1675 size_t fftSize = getFFTSize(v);
|
Chris@130
|
1676 FFTModel *fft = getFFTModel(v);
|
Chris@114
|
1677 if (!fft) {
|
Chris@130
|
1678 std::cerr << "ERROR: SpectrogramLayer::paint(): No FFT model, returning" << std::endl;
|
Chris@0
|
1679 return;
|
Chris@0
|
1680 }
|
Chris@0
|
1681
|
Chris@95
|
1682 PixmapCache &cache = m_pixmapCaches[v];
|
Chris@95
|
1683
|
Chris@95
|
1684 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@95
|
1685 std::cerr << "SpectrogramLayer::paint(): pixmap cache valid area " << cache.validArea.x() << ", " << cache.validArea.y() << ", " << cache.validArea.width() << "x" << cache.validArea.height() << std::endl;
|
Chris@95
|
1686 #endif
|
Chris@95
|
1687
|
Chris@0
|
1688 bool stillCacheing = (m_updateTimer != 0);
|
Chris@0
|
1689
|
Chris@0
|
1690 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@0
|
1691 std::cerr << "SpectrogramLayer::paint(): Still cacheing = " << stillCacheing << std::endl;
|
Chris@0
|
1692 #endif
|
Chris@0
|
1693
|
Chris@44
|
1694 long startFrame = v->getStartFrame();
|
Chris@44
|
1695 int zoomLevel = v->getZoomLevel();
|
Chris@0
|
1696
|
Chris@0
|
1697 int x0 = 0;
|
Chris@44
|
1698 int x1 = v->width();
|
Chris@0
|
1699 int y0 = 0;
|
Chris@44
|
1700 int y1 = v->height();
|
Chris@0
|
1701
|
Chris@0
|
1702 bool recreateWholePixmapCache = true;
|
Chris@0
|
1703
|
Chris@95
|
1704 x0 = rect.left();
|
Chris@95
|
1705 x1 = rect.right() + 1;
|
Chris@95
|
1706 y0 = rect.top();
|
Chris@95
|
1707 y1 = rect.bottom() + 1;
|
Chris@95
|
1708
|
Chris@95
|
1709 if (cache.validArea.width() > 0) {
|
Chris@95
|
1710
|
Chris@95
|
1711 if (int(cache.zoomLevel) == zoomLevel &&
|
Chris@95
|
1712 cache.pixmap.width() == v->width() &&
|
Chris@95
|
1713 cache.pixmap.height() == v->height()) {
|
Chris@95
|
1714
|
Chris@95
|
1715 if (v->getXForFrame(cache.startFrame) ==
|
Chris@95
|
1716 v->getXForFrame(startFrame) &&
|
Chris@95
|
1717 cache.validArea.x() <= x0 &&
|
Chris@95
|
1718 cache.validArea.x() + cache.validArea.width() >= x1) {
|
Chris@0
|
1719
|
Chris@0
|
1720 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@0
|
1721 std::cerr << "SpectrogramLayer: pixmap cache good" << std::endl;
|
Chris@0
|
1722 #endif
|
Chris@0
|
1723
|
Chris@95
|
1724 paint.drawPixmap(rect, cache.pixmap, rect);
|
Chris@121
|
1725 illuminateLocalFeatures(v, paint);
|
Chris@0
|
1726 return;
|
Chris@0
|
1727
|
Chris@0
|
1728 } else {
|
Chris@0
|
1729
|
Chris@0
|
1730 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@0
|
1731 std::cerr << "SpectrogramLayer: pixmap cache partially OK" << std::endl;
|
Chris@0
|
1732 #endif
|
Chris@0
|
1733
|
Chris@0
|
1734 recreateWholePixmapCache = false;
|
Chris@0
|
1735
|
Chris@95
|
1736 int dx = v->getXForFrame(cache.startFrame) -
|
Chris@44
|
1737 v->getXForFrame(startFrame);
|
Chris@0
|
1738
|
Chris@0
|
1739 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@95
|
1740 std::cerr << "SpectrogramLayer: dx = " << dx << " (pixmap cache " << cache.pixmap.width() << "x" << cache.pixmap.height() << ")" << std::endl;
|
Chris@0
|
1741 #endif
|
Chris@0
|
1742
|
Chris@95
|
1743 if (dx != 0 &&
|
Chris@95
|
1744 dx > -cache.pixmap.width() &&
|
Chris@95
|
1745 dx < cache.pixmap.width()) {
|
Chris@0
|
1746
|
Chris@0
|
1747 #if defined(Q_WS_WIN32) || defined(Q_WS_MAC)
|
Chris@0
|
1748 // Copying a pixmap to itself doesn't work
|
Chris@0
|
1749 // properly on Windows or Mac (it only works when
|
Chris@0
|
1750 // moving in one direction).
|
Chris@0
|
1751
|
Chris@0
|
1752 //!!! Need a utility function for this
|
Chris@0
|
1753
|
Chris@0
|
1754 static QPixmap *tmpPixmap = 0;
|
Chris@0
|
1755 if (!tmpPixmap ||
|
Chris@95
|
1756 tmpPixmap->width() != cache.pixmap.width() ||
|
Chris@95
|
1757 tmpPixmap->height() != cache.pixmap.height()) {
|
Chris@0
|
1758 delete tmpPixmap;
|
Chris@95
|
1759 tmpPixmap = new QPixmap(cache.pixmap.width(),
|
Chris@95
|
1760 cache.pixmap.height());
|
Chris@0
|
1761 }
|
Chris@0
|
1762 QPainter cachePainter;
|
Chris@0
|
1763 cachePainter.begin(tmpPixmap);
|
Chris@95
|
1764 cachePainter.drawPixmap(0, 0, cache.pixmap);
|
Chris@0
|
1765 cachePainter.end();
|
Chris@95
|
1766 cachePainter.begin(&cache.pixmap);
|
Chris@0
|
1767 cachePainter.drawPixmap(dx, 0, *tmpPixmap);
|
Chris@0
|
1768 cachePainter.end();
|
Chris@0
|
1769 #else
|
Chris@95
|
1770 QPainter cachePainter(&cache.pixmap);
|
Chris@95
|
1771 cachePainter.drawPixmap(dx, 0, cache.pixmap);
|
Chris@0
|
1772 cachePainter.end();
|
Chris@0
|
1773 #endif
|
Chris@0
|
1774
|
Chris@95
|
1775 int px = cache.validArea.x();
|
Chris@95
|
1776 int pw = cache.validArea.width();
|
Chris@0
|
1777
|
Chris@0
|
1778 if (dx < 0) {
|
Chris@95
|
1779 x0 = cache.pixmap.width() + dx;
|
Chris@95
|
1780 x1 = cache.pixmap.width();
|
Chris@95
|
1781 px += dx;
|
Chris@95
|
1782 if (px < 0) {
|
Chris@95
|
1783 pw += px;
|
Chris@95
|
1784 px = 0;
|
Chris@95
|
1785 if (pw < 0) pw = 0;
|
Chris@95
|
1786 }
|
Chris@0
|
1787 } else {
|
Chris@0
|
1788 x0 = 0;
|
Chris@0
|
1789 x1 = dx;
|
Chris@95
|
1790 px += dx;
|
Chris@95
|
1791 if (px + pw > cache.pixmap.width()) {
|
Chris@95
|
1792 pw = int(cache.pixmap.width()) - px;
|
Chris@95
|
1793 if (pw < 0) pw = 0;
|
Chris@95
|
1794 }
|
Chris@0
|
1795 }
|
Chris@95
|
1796
|
Chris@95
|
1797 cache.validArea =
|
Chris@95
|
1798 QRect(px, cache.validArea.y(),
|
Chris@95
|
1799 pw, cache.validArea.height());
|
Chris@95
|
1800
|
Chris@95
|
1801 paint.drawPixmap(rect & cache.validArea,
|
Chris@95
|
1802 cache.pixmap,
|
Chris@95
|
1803 rect & cache.validArea);
|
Chris@0
|
1804 }
|
Chris@0
|
1805 }
|
Chris@0
|
1806 } else {
|
Chris@0
|
1807 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@0
|
1808 std::cerr << "SpectrogramLayer: pixmap cache useless" << std::endl;
|
Chris@0
|
1809 #endif
|
Chris@95
|
1810 cache.validArea = QRect();
|
Chris@0
|
1811 }
|
Chris@0
|
1812 }
|
Chris@95
|
1813
|
Chris@92
|
1814 /*
|
Chris@0
|
1815 if (stillCacheing) {
|
Chris@0
|
1816 x0 = rect.left();
|
Chris@0
|
1817 x1 = rect.right() + 1;
|
Chris@0
|
1818 y0 = rect.top();
|
Chris@0
|
1819 y1 = rect.bottom() + 1;
|
Chris@0
|
1820 }
|
Chris@92
|
1821 */
|
Chris@95
|
1822
|
Chris@95
|
1823 if (recreateWholePixmapCache) {
|
Chris@95
|
1824 x0 = 0;
|
Chris@95
|
1825 x1 = v->width();
|
Chris@95
|
1826 }
|
Chris@95
|
1827
|
Chris@119
|
1828 if (updateViewMagnitudes(v)) {
|
Chris@119
|
1829 std::cerr << "SpectrogramLayer: magnitude range changed to [" << m_viewMags[v].getMin() << "->" << m_viewMags[v].getMax() << "]" << std::endl;
|
Chris@119
|
1830 } else {
|
Chris@119
|
1831 std::cerr << "No change in magnitude range [" << m_viewMags[v].getMin() << "->" << m_viewMags[v].getMax() << "]" << std::endl;
|
Chris@119
|
1832 }
|
Chris@119
|
1833
|
Chris@96
|
1834 int paintBlockWidth = (300000 / zoomLevel);
|
Chris@96
|
1835 if (paintBlockWidth < 20) paintBlockWidth = 20;
|
Chris@96
|
1836
|
Chris@96
|
1837 if (cache.validArea.width() > 0) {
|
Chris@96
|
1838
|
Chris@96
|
1839 int vx0 = 0, vx1 = 0;
|
Chris@96
|
1840 vx0 = cache.validArea.x();
|
Chris@96
|
1841 vx1 = cache.validArea.x() + cache.validArea.width();
|
Chris@96
|
1842
|
Chris@96
|
1843 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@96
|
1844 std::cerr << "x0 " << x0 << ", x1 " << x1 << ", vx0 " << vx0 << ", vx1 " << vx1 << ", paintBlockWidth " << paintBlockWidth << std::endl;
|
Chris@96
|
1845 #endif
|
Chris@96
|
1846 if (x0 < vx0) {
|
Chris@96
|
1847 if (x0 + paintBlockWidth < vx0) {
|
Chris@96
|
1848 x0 = vx0 - paintBlockWidth;
|
Chris@96
|
1849 } else {
|
Chris@96
|
1850 x0 = 0;
|
Chris@96
|
1851 }
|
Chris@96
|
1852 } else if (x0 > vx1) {
|
Chris@96
|
1853 x0 = vx1;
|
Chris@96
|
1854 }
|
Chris@95
|
1855
|
Chris@96
|
1856 if (x1 < vx0) {
|
Chris@96
|
1857 x1 = vx0;
|
Chris@96
|
1858 } else if (x1 > vx1) {
|
Chris@96
|
1859 if (vx1 + paintBlockWidth < x1) {
|
Chris@96
|
1860 x1 = vx1 + paintBlockWidth;
|
Chris@96
|
1861 } else {
|
Chris@96
|
1862 x1 = v->width();
|
Chris@95
|
1863 }
|
Chris@96
|
1864 }
|
Chris@95
|
1865
|
Chris@96
|
1866 cache.validArea = QRect
|
Chris@96
|
1867 (std::min(vx0, x0), cache.validArea.y(),
|
Chris@96
|
1868 std::max(vx1 - std::min(vx0, x0),
|
Chris@96
|
1869 x1 - std::min(vx0, x0)),
|
Chris@96
|
1870 cache.validArea.height());
|
Chris@95
|
1871
|
Chris@96
|
1872 } else {
|
Chris@96
|
1873 if (x1 > x0 + paintBlockWidth) {
|
Chris@96
|
1874 x1 = x0 + paintBlockWidth;
|
Chris@95
|
1875 }
|
Chris@96
|
1876 cache.validArea = QRect(x0, 0, x1 - x0, v->height());
|
Chris@95
|
1877 }
|
Chris@95
|
1878
|
Chris@0
|
1879 int w = x1 - x0;
|
Chris@0
|
1880 int h = y1 - y0;
|
Chris@0
|
1881
|
Chris@95
|
1882 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@95
|
1883 std::cerr << "x0 " << x0 << ", x1 " << x1 << ", w " << w << ", h " << h << std::endl;
|
Chris@95
|
1884 #endif
|
Chris@95
|
1885
|
Chris@95
|
1886 if (m_drawBuffer.width() < w || m_drawBuffer.height() < h) {
|
Chris@95
|
1887 m_drawBuffer = QImage(w, h, QImage::Format_RGB32);
|
Chris@95
|
1888 }
|
Chris@95
|
1889
|
Chris@97
|
1890 m_drawBuffer.fill(m_colourMap.getColour(0).rgb());
|
Chris@35
|
1891
|
Chris@37
|
1892 int sr = m_model->getSampleRate();
|
Chris@122
|
1893
|
Chris@122
|
1894 // Set minFreq and maxFreq to the frequency extents of the possibly
|
Chris@122
|
1895 // zero-padded visible bin range, and displayMinFreq and displayMaxFreq
|
Chris@122
|
1896 // to the actual scale frequency extents (presumably not zero padded).
|
Chris@35
|
1897
|
Chris@114
|
1898 size_t bins = fftSize / 2;
|
Chris@35
|
1899 if (m_maxFrequency > 0) {
|
Chris@114
|
1900 bins = int((double(m_maxFrequency) * fftSize) / sr + 0.1);
|
Chris@114
|
1901 if (bins > fftSize / 2) bins = fftSize / 2;
|
Chris@35
|
1902 }
|
Chris@111
|
1903
|
Chris@40
|
1904 size_t minbin = 1;
|
Chris@37
|
1905 if (m_minFrequency > 0) {
|
Chris@114
|
1906 minbin = int((double(m_minFrequency) * fftSize) / sr + 0.1);
|
Chris@40
|
1907 if (minbin < 1) minbin = 1;
|
Chris@37
|
1908 if (minbin >= bins) minbin = bins - 1;
|
Chris@37
|
1909 }
|
Chris@37
|
1910
|
Chris@114
|
1911 float minFreq = (float(minbin) * sr) / fftSize;
|
Chris@114
|
1912 float maxFreq = (float(bins) * sr) / fftSize;
|
Chris@0
|
1913
|
Chris@122
|
1914 float displayMinFreq = minFreq;
|
Chris@122
|
1915 float displayMaxFreq = maxFreq;
|
Chris@122
|
1916
|
Chris@122
|
1917 if (fftSize != m_fftSize) {
|
Chris@122
|
1918 displayMinFreq = getEffectiveMinFrequency();
|
Chris@122
|
1919 displayMaxFreq = getEffectiveMaxFrequency();
|
Chris@122
|
1920 }
|
Chris@122
|
1921
|
Chris@92
|
1922 float ymag[h];
|
Chris@92
|
1923 float ydiv[h];
|
Chris@122
|
1924 float yval[bins + 1]; //!!! cache this?
|
Chris@92
|
1925
|
Chris@38
|
1926 size_t increment = getWindowIncrement();
|
Chris@40
|
1927
|
Chris@40
|
1928 bool logarithmic = (m_frequencyScale == LogFrequencyScale);
|
Chris@38
|
1929
|
Chris@92
|
1930 for (size_t q = minbin; q <= bins; ++q) {
|
Chris@114
|
1931 float f0 = (float(q) * sr) / fftSize;
|
Chris@122
|
1932 yval[q] = v->getYForFrequency(f0, displayMinFreq, displayMaxFreq,
|
Chris@122
|
1933 logarithmic);
|
Chris@122
|
1934 // std::cerr << "min: " << minFreq << ", max: " << maxFreq << ", yval[" << q << "]: " << yval[q] << std::endl;
|
Chris@92
|
1935 }
|
Chris@92
|
1936
|
Chris@119
|
1937 MagnitudeRange overallMag = m_viewMags[v];
|
Chris@119
|
1938 bool overallMagChanged = false;
|
Chris@119
|
1939
|
Chris@35
|
1940 for (int x = 0; x < w; ++x) {
|
Chris@35
|
1941
|
Chris@35
|
1942 for (int y = 0; y < h; ++y) {
|
Chris@40
|
1943 ymag[y] = 0.0;
|
Chris@40
|
1944 ydiv[y] = 0.0;
|
Chris@35
|
1945 }
|
Chris@35
|
1946
|
Chris@35
|
1947 float s0 = 0, s1 = 0;
|
Chris@35
|
1948
|
Chris@44
|
1949 if (!getXBinRange(v, x0 + x, s0, s1)) {
|
Chris@95
|
1950 assert(x <= m_drawBuffer.width());
|
Chris@35
|
1951 continue;
|
Chris@35
|
1952 }
|
Chris@35
|
1953
|
Chris@35
|
1954 int s0i = int(s0 + 0.001);
|
Chris@35
|
1955 int s1i = int(s1);
|
Chris@35
|
1956
|
Chris@114
|
1957 if (s1i >= fft->getWidth()) {
|
Chris@114
|
1958 if (s0i >= fft->getWidth()) {
|
Chris@45
|
1959 continue;
|
Chris@45
|
1960 } else {
|
Chris@45
|
1961 s1i = s0i;
|
Chris@45
|
1962 }
|
Chris@45
|
1963 }
|
Chris@92
|
1964
|
Chris@92
|
1965 for (int s = s0i; s <= s1i; ++s) {
|
Chris@92
|
1966
|
Chris@114
|
1967 if (!fft->isColumnReady(s)) continue;
|
Chris@119
|
1968 MagnitudeRange mag;
|
Chris@92
|
1969
|
Chris@92
|
1970 for (size_t q = minbin; q < bins; ++q) {
|
Chris@92
|
1971
|
Chris@92
|
1972 float y0 = yval[q + 1];
|
Chris@92
|
1973 float y1 = yval[q];
|
Chris@92
|
1974
|
Chris@40
|
1975 if (m_binDisplay == PeakBins ||
|
Chris@40
|
1976 m_binDisplay == PeakFrequencies) {
|
Chris@114
|
1977 if (!fft->isLocalPeak(s, q)) continue;
|
Chris@40
|
1978 }
|
Chris@114
|
1979
|
Chris@114
|
1980 if (m_threshold != 0.f &&
|
Chris@114
|
1981 !fft->isOverThreshold(s, q, m_threshold)) {
|
Chris@114
|
1982 continue;
|
Chris@114
|
1983 }
|
Chris@40
|
1984
|
Chris@35
|
1985 float sprop = 1.0;
|
Chris@35
|
1986 if (s == s0i) sprop *= (s + 1) - s0;
|
Chris@35
|
1987 if (s == s1i) sprop *= s1 - s;
|
Chris@35
|
1988
|
Chris@38
|
1989 if (m_binDisplay == PeakFrequencies &&
|
Chris@114
|
1990 s < int(fft->getWidth()) - 1) {
|
Chris@35
|
1991
|
Chris@38
|
1992 bool steady = false;
|
Chris@92
|
1993 float f = calculateFrequency(q,
|
Chris@38
|
1994 m_windowSize,
|
Chris@38
|
1995 increment,
|
Chris@38
|
1996 sr,
|
Chris@114
|
1997 fft->getPhaseAt(s, q),
|
Chris@114
|
1998 fft->getPhaseAt(s+1, q),
|
Chris@38
|
1999 steady);
|
Chris@40
|
2000
|
Chris@44
|
2001 y0 = y1 = v->getYForFrequency
|
Chris@122
|
2002 (f, displayMinFreq, displayMaxFreq, logarithmic);
|
Chris@35
|
2003 }
|
Chris@38
|
2004
|
Chris@35
|
2005 int y0i = int(y0 + 0.001);
|
Chris@35
|
2006 int y1i = int(y1);
|
Chris@35
|
2007
|
Chris@92
|
2008 float value;
|
Chris@92
|
2009
|
Chris@92
|
2010 if (m_colourScale == PhaseColourScale) {
|
Chris@114
|
2011 value = fft->getPhaseAt(s, q);
|
Chris@92
|
2012 } else if (m_normalizeColumns) {
|
Chris@119
|
2013 value = fft->getNormalizedMagnitudeAt(s, q);
|
Chris@119
|
2014 mag.sample(value);
|
Chris@119
|
2015 value *= m_gain;
|
Chris@92
|
2016 } else {
|
Chris@119
|
2017 value = fft->getMagnitudeAt(s, q);
|
Chris@119
|
2018 mag.sample(value);
|
Chris@119
|
2019 value *= m_gain;
|
Chris@92
|
2020 }
|
Chris@92
|
2021
|
Chris@35
|
2022 for (int y = y0i; y <= y1i; ++y) {
|
Chris@35
|
2023
|
Chris@35
|
2024 if (y < 0 || y >= h) continue;
|
Chris@35
|
2025
|
Chris@35
|
2026 float yprop = sprop;
|
Chris@35
|
2027 if (y == y0i) yprop *= (y + 1) - y0;
|
Chris@35
|
2028 if (y == y1i) yprop *= y1 - y;
|
Chris@37
|
2029 ymag[y] += yprop * value;
|
Chris@35
|
2030 ydiv[y] += yprop;
|
Chris@35
|
2031 }
|
Chris@35
|
2032 }
|
Chris@119
|
2033
|
Chris@119
|
2034 if (mag.isSet()) {
|
Chris@119
|
2035
|
Chris@119
|
2036 m_columnMags[s].sample(mag);
|
Chris@119
|
2037
|
Chris@119
|
2038 if (overallMag.sample(mag)) {
|
Chris@119
|
2039 //!!! scaling would change here
|
Chris@119
|
2040 overallMagChanged = true;
|
Chris@119
|
2041 std::cerr << "Overall mag changed (again?) at column " << s << ", to [" << overallMag.getMin() << "->" << overallMag.getMax() << "]" << std::endl;
|
Chris@119
|
2042 }
|
Chris@119
|
2043 }
|
Chris@35
|
2044 }
|
Chris@35
|
2045
|
Chris@35
|
2046 for (int y = 0; y < h; ++y) {
|
Chris@35
|
2047
|
Chris@35
|
2048 if (ydiv[y] > 0.0) {
|
Chris@40
|
2049
|
Chris@40
|
2050 unsigned char pixel = 0;
|
Chris@40
|
2051
|
Chris@38
|
2052 float avg = ymag[y] / ydiv[y];
|
Chris@119
|
2053 pixel = getDisplayValue(v, avg);
|
Chris@40
|
2054
|
Chris@95
|
2055 assert(x <= m_drawBuffer.width());
|
Chris@86
|
2056 QColor c = m_colourMap.getColour(pixel);
|
Chris@95
|
2057 m_drawBuffer.setPixel(x, y,
|
Chris@95
|
2058 qRgb(c.red(), c.green(), c.blue()));
|
Chris@35
|
2059 }
|
Chris@35
|
2060 }
|
Chris@35
|
2061 }
|
Chris@35
|
2062
|
Chris@119
|
2063 if (overallMagChanged) {
|
Chris@119
|
2064 m_viewMags[v] = overallMag;
|
Chris@119
|
2065 std::cerr << "Overall mag is now [" << m_viewMags[v].getMin() << "->" << m_viewMags[v].getMax() << "] - will be updating" << std::endl;
|
Chris@119
|
2066 } else {
|
Chris@119
|
2067 std::cerr << "Overall mag unchanged at [" << m_viewMags[v].getMin() << "->" << m_viewMags[v].getMax() << "]" << std::endl;
|
Chris@119
|
2068 }
|
Chris@119
|
2069
|
Chris@95
|
2070 paint.drawImage(x0, y0, m_drawBuffer, 0, 0, w, h);
|
Chris@0
|
2071
|
Chris@0
|
2072 if (recreateWholePixmapCache) {
|
Chris@95
|
2073 cache.pixmap = QPixmap(v->width(), v->height());
|
Chris@0
|
2074 }
|
Chris@0
|
2075
|
Chris@95
|
2076 QPainter cachePainter(&cache.pixmap);
|
Chris@95
|
2077 cachePainter.drawImage(x0, y0, m_drawBuffer, 0, 0, w, h);
|
Chris@0
|
2078 cachePainter.end();
|
Chris@119
|
2079
|
Chris@120
|
2080 if (!m_normalizeVisibleArea || !overallMagChanged) {
|
Chris@0
|
2081
|
Chris@119
|
2082 cache.startFrame = startFrame;
|
Chris@119
|
2083 cache.zoomLevel = zoomLevel;
|
Chris@119
|
2084
|
Chris@119
|
2085 if (cache.validArea.x() > 0) {
|
Chris@95
|
2086 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@119
|
2087 std::cerr << "SpectrogramLayer::paint() updating left" << std::endl;
|
Chris@95
|
2088 #endif
|
Chris@119
|
2089 v->update(0, 0, cache.validArea.x(), v->height());
|
Chris@119
|
2090 }
|
Chris@119
|
2091
|
Chris@119
|
2092 if (cache.validArea.x() + cache.validArea.width() <
|
Chris@119
|
2093 cache.pixmap.width()) {
|
Chris@95
|
2094 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@119
|
2095 std::cerr << "SpectrogramLayer::paint() updating right ("
|
Chris@119
|
2096 << cache.validArea.x() + cache.validArea.width()
|
Chris@119
|
2097 << ", "
|
Chris@119
|
2098 << cache.pixmap.width() - (cache.validArea.x() +
|
Chris@119
|
2099 cache.validArea.width())
|
Chris@119
|
2100 << ")" << std::endl;
|
Chris@95
|
2101 #endif
|
Chris@119
|
2102 v->update(cache.validArea.x() + cache.validArea.width(),
|
Chris@119
|
2103 0,
|
Chris@119
|
2104 cache.pixmap.width() - (cache.validArea.x() +
|
Chris@119
|
2105 cache.validArea.width()),
|
Chris@119
|
2106 v->height());
|
Chris@119
|
2107 }
|
Chris@119
|
2108 } else {
|
Chris@119
|
2109 // overallMagChanged
|
Chris@119
|
2110 cache.validArea = QRect();
|
Chris@119
|
2111 v->update();
|
Chris@95
|
2112 }
|
Chris@0
|
2113
|
Chris@121
|
2114 illuminateLocalFeatures(v, paint);
|
Chris@120
|
2115
|
Chris@0
|
2116 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@0
|
2117 std::cerr << "SpectrogramLayer::paint() returning" << std::endl;
|
Chris@0
|
2118 #endif
|
Chris@0
|
2119 }
|
Chris@0
|
2120
|
Chris@121
|
2121 void
|
Chris@121
|
2122 SpectrogramLayer::illuminateLocalFeatures(View *v, QPainter &paint) const
|
Chris@121
|
2123 {
|
Chris@121
|
2124 QPoint localPos;
|
Chris@121
|
2125 if (!v->shouldIlluminateLocalFeatures(this, localPos) || !m_model) {
|
Chris@121
|
2126 return;
|
Chris@121
|
2127 }
|
Chris@121
|
2128
|
Chris@121
|
2129 std::cerr << "SpectrogramLayer: illuminateLocalFeatures("
|
Chris@121
|
2130 << localPos.x() << "," << localPos.y() << ")" << std::endl;
|
Chris@121
|
2131
|
Chris@121
|
2132 float s0, s1;
|
Chris@121
|
2133 float f0, f1;
|
Chris@121
|
2134
|
Chris@121
|
2135 if (getXBinRange(v, localPos.x(), s0, s1) &&
|
Chris@121
|
2136 getYBinSourceRange(v, localPos.y(), f0, f1)) {
|
Chris@121
|
2137
|
Chris@121
|
2138 int s0i = int(s0 + 0.001);
|
Chris@121
|
2139 int s1i = int(s1);
|
Chris@121
|
2140
|
Chris@121
|
2141 int x0 = v->getXForFrame(s0i * getWindowIncrement());
|
Chris@121
|
2142 int x1 = v->getXForFrame((s1i + 1) * getWindowIncrement());
|
Chris@121
|
2143
|
Chris@121
|
2144 int y1 = getYForFrequency(v, f1);
|
Chris@121
|
2145 int y0 = getYForFrequency(v, f0);
|
Chris@121
|
2146
|
Chris@121
|
2147 std::cerr << "SpectrogramLayer: illuminate "
|
Chris@121
|
2148 << x0 << "," << y1 << " -> " << x1 << "," << y0 << std::endl;
|
Chris@121
|
2149
|
Chris@121
|
2150 paint.setPen(Qt::white);
|
Chris@121
|
2151 paint.drawRect(x0, y1, x1 - x0 + 1, y0 - y1 + 1);
|
Chris@121
|
2152 }
|
Chris@121
|
2153 }
|
Chris@121
|
2154
|
Chris@42
|
2155 float
|
Chris@44
|
2156 SpectrogramLayer::getYForFrequency(View *v, float frequency) const
|
Chris@42
|
2157 {
|
Chris@44
|
2158 return v->getYForFrequency(frequency,
|
Chris@44
|
2159 getEffectiveMinFrequency(),
|
Chris@44
|
2160 getEffectiveMaxFrequency(),
|
Chris@44
|
2161 m_frequencyScale == LogFrequencyScale);
|
Chris@42
|
2162 }
|
Chris@42
|
2163
|
Chris@42
|
2164 float
|
Chris@44
|
2165 SpectrogramLayer::getFrequencyForY(View *v, int y) const
|
Chris@42
|
2166 {
|
Chris@44
|
2167 return v->getFrequencyForY(y,
|
Chris@44
|
2168 getEffectiveMinFrequency(),
|
Chris@44
|
2169 getEffectiveMaxFrequency(),
|
Chris@44
|
2170 m_frequencyScale == LogFrequencyScale);
|
Chris@42
|
2171 }
|
Chris@42
|
2172
|
Chris@0
|
2173 int
|
Chris@115
|
2174 SpectrogramLayer::getCompletion(View *v) const
|
Chris@0
|
2175 {
|
Chris@115
|
2176 if (m_updateTimer == 0) return 100;
|
Chris@130
|
2177 if (m_fftModels.find(v) == m_fftModels.end()) return 100;
|
Chris@130
|
2178
|
Chris@130
|
2179 size_t completion = m_fftModels[v].first->getCompletion();
|
Chris@115
|
2180 std::cerr << "SpectrogramLayer::getCompletion: completion = " << completion << std::endl;
|
Chris@0
|
2181 return completion;
|
Chris@0
|
2182 }
|
Chris@0
|
2183
|
Chris@28
|
2184 bool
|
Chris@101
|
2185 SpectrogramLayer::getValueExtents(float &min, float &max,
|
Chris@101
|
2186 bool &logarithmic, QString &unit) const
|
Chris@79
|
2187 {
|
Chris@79
|
2188 min = getEffectiveMinFrequency();
|
Chris@79
|
2189 max = getEffectiveMaxFrequency();
|
Chris@101
|
2190 logarithmic = (m_frequencyScale == LogFrequencyScale);
|
Chris@79
|
2191 unit = "Hz";
|
Chris@79
|
2192 return true;
|
Chris@79
|
2193 }
|
Chris@79
|
2194
|
Chris@79
|
2195 bool
|
Chris@101
|
2196 SpectrogramLayer::getDisplayExtents(float &min, float &max) const
|
Chris@101
|
2197 {
|
Chris@101
|
2198 min = getEffectiveMinFrequency();
|
Chris@101
|
2199 max = getEffectiveMaxFrequency();
|
Chris@101
|
2200 return true;
|
Chris@101
|
2201 }
|
Chris@101
|
2202
|
Chris@101
|
2203 bool
|
Chris@120
|
2204 SpectrogramLayer::setDisplayExtents(float min, float max)
|
Chris@120
|
2205 {
|
Chris@120
|
2206 if (!m_model) return false;
|
Chris@120
|
2207 if (min < 0) min = 0;
|
Chris@120
|
2208 if (max > m_model->getSampleRate()/2) max = m_model->getSampleRate()/2;
|
Chris@120
|
2209
|
Chris@120
|
2210 size_t minf = lrintf(min);
|
Chris@120
|
2211 size_t maxf = lrintf(max);
|
Chris@120
|
2212
|
Chris@120
|
2213 if (m_minFrequency == minf && m_maxFrequency == maxf) return true;
|
Chris@120
|
2214
|
Chris@120
|
2215 invalidatePixmapCaches();
|
Chris@120
|
2216 invalidateMagnitudes();
|
Chris@120
|
2217
|
Chris@120
|
2218 m_minFrequency = minf;
|
Chris@120
|
2219 m_maxFrequency = maxf;
|
Chris@120
|
2220
|
Chris@120
|
2221 emit layerParametersChanged();
|
Chris@120
|
2222
|
Chris@120
|
2223 return true;
|
Chris@120
|
2224 }
|
Chris@120
|
2225
|
Chris@120
|
2226 bool
|
Chris@44
|
2227 SpectrogramLayer::snapToFeatureFrame(View *v, int &frame,
|
Chris@28
|
2228 size_t &resolution,
|
Chris@28
|
2229 SnapType snap) const
|
Chris@13
|
2230 {
|
Chris@13
|
2231 resolution = getWindowIncrement();
|
Chris@28
|
2232 int left = (frame / resolution) * resolution;
|
Chris@28
|
2233 int right = left + resolution;
|
Chris@28
|
2234
|
Chris@28
|
2235 switch (snap) {
|
Chris@28
|
2236 case SnapLeft: frame = left; break;
|
Chris@28
|
2237 case SnapRight: frame = right; break;
|
Chris@28
|
2238 case SnapNearest:
|
Chris@28
|
2239 case SnapNeighbouring:
|
Chris@28
|
2240 if (frame - left > right - frame) frame = right;
|
Chris@28
|
2241 else frame = left;
|
Chris@28
|
2242 break;
|
Chris@28
|
2243 }
|
Chris@28
|
2244
|
Chris@28
|
2245 return true;
|
Chris@28
|
2246 }
|
Chris@13
|
2247
|
Chris@77
|
2248 bool
|
Chris@77
|
2249 SpectrogramLayer::getCrosshairExtents(View *v, QPainter &paint,
|
Chris@77
|
2250 QPoint cursorPos,
|
Chris@77
|
2251 std::vector<QRect> &extents) const
|
Chris@77
|
2252 {
|
Chris@77
|
2253 QRect vertical(cursorPos.x() - 12, 0, 12, v->height());
|
Chris@77
|
2254 extents.push_back(vertical);
|
Chris@77
|
2255
|
Chris@77
|
2256 QRect horizontal(0, cursorPos.y(), cursorPos.x(), 1);
|
Chris@77
|
2257 extents.push_back(horizontal);
|
Chris@77
|
2258
|
Chris@77
|
2259 return true;
|
Chris@77
|
2260 }
|
Chris@77
|
2261
|
Chris@77
|
2262 void
|
Chris@77
|
2263 SpectrogramLayer::paintCrosshairs(View *v, QPainter &paint,
|
Chris@77
|
2264 QPoint cursorPos) const
|
Chris@77
|
2265 {
|
Chris@77
|
2266 paint.save();
|
Chris@77
|
2267 paint.setPen(m_crosshairColour);
|
Chris@77
|
2268
|
Chris@77
|
2269 paint.drawLine(0, cursorPos.y(), cursorPos.x() - 1, cursorPos.y());
|
Chris@77
|
2270 paint.drawLine(cursorPos.x(), 0, cursorPos.x(), v->height());
|
Chris@77
|
2271
|
Chris@77
|
2272 float fundamental = getFrequencyForY(v, cursorPos.y());
|
Chris@77
|
2273
|
Chris@77
|
2274 int harmonic = 2;
|
Chris@77
|
2275
|
Chris@77
|
2276 while (harmonic < 100) {
|
Chris@77
|
2277
|
Chris@77
|
2278 float hy = lrintf(getYForFrequency(v, fundamental * harmonic));
|
Chris@77
|
2279 if (hy < 0 || hy > v->height()) break;
|
Chris@77
|
2280
|
Chris@77
|
2281 int len = 7;
|
Chris@77
|
2282
|
Chris@77
|
2283 if (harmonic % 2 == 0) {
|
Chris@77
|
2284 if (harmonic % 4 == 0) {
|
Chris@77
|
2285 len = 12;
|
Chris@77
|
2286 } else {
|
Chris@77
|
2287 len = 10;
|
Chris@77
|
2288 }
|
Chris@77
|
2289 }
|
Chris@77
|
2290
|
Chris@77
|
2291 paint.drawLine(cursorPos.x() - len,
|
Chris@77
|
2292 hy,
|
Chris@77
|
2293 cursorPos.x(),
|
Chris@77
|
2294 hy);
|
Chris@77
|
2295
|
Chris@77
|
2296 ++harmonic;
|
Chris@77
|
2297 }
|
Chris@77
|
2298
|
Chris@77
|
2299 paint.restore();
|
Chris@77
|
2300 }
|
Chris@77
|
2301
|
Chris@25
|
2302 QString
|
Chris@44
|
2303 SpectrogramLayer::getFeatureDescription(View *v, QPoint &pos) const
|
Chris@25
|
2304 {
|
Chris@25
|
2305 int x = pos.x();
|
Chris@25
|
2306 int y = pos.y();
|
Chris@0
|
2307
|
Chris@25
|
2308 if (!m_model || !m_model->isOK()) return "";
|
Chris@0
|
2309
|
Chris@38
|
2310 float magMin = 0, magMax = 0;
|
Chris@38
|
2311 float phaseMin = 0, phaseMax = 0;
|
Chris@0
|
2312 float freqMin = 0, freqMax = 0;
|
Chris@35
|
2313 float adjFreqMin = 0, adjFreqMax = 0;
|
Chris@25
|
2314 QString pitchMin, pitchMax;
|
Chris@0
|
2315 RealTime rtMin, rtMax;
|
Chris@0
|
2316
|
Chris@38
|
2317 bool haveValues = false;
|
Chris@0
|
2318
|
Chris@44
|
2319 if (!getXBinSourceRange(v, x, rtMin, rtMax)) {
|
Chris@38
|
2320 return "";
|
Chris@38
|
2321 }
|
Chris@44
|
2322 if (getXYBinSourceRange(v, x, y, magMin, magMax, phaseMin, phaseMax)) {
|
Chris@38
|
2323 haveValues = true;
|
Chris@38
|
2324 }
|
Chris@0
|
2325
|
Chris@35
|
2326 QString adjFreqText = "", adjPitchText = "";
|
Chris@35
|
2327
|
Chris@38
|
2328 if (m_binDisplay == PeakFrequencies) {
|
Chris@35
|
2329
|
Chris@44
|
2330 if (!getAdjustedYBinSourceRange(v, x, y, freqMin, freqMax,
|
Chris@38
|
2331 adjFreqMin, adjFreqMax)) {
|
Chris@38
|
2332 return "";
|
Chris@38
|
2333 }
|
Chris@35
|
2334
|
Chris@35
|
2335 if (adjFreqMin != adjFreqMax) {
|
Chris@65
|
2336 adjFreqText = tr("Peak Frequency:\t%1 - %2 Hz\n")
|
Chris@35
|
2337 .arg(adjFreqMin).arg(adjFreqMax);
|
Chris@35
|
2338 } else {
|
Chris@65
|
2339 adjFreqText = tr("Peak Frequency:\t%1 Hz\n")
|
Chris@35
|
2340 .arg(adjFreqMin);
|
Chris@38
|
2341 }
|
Chris@38
|
2342
|
Chris@38
|
2343 QString pmin = Pitch::getPitchLabelForFrequency(adjFreqMin);
|
Chris@38
|
2344 QString pmax = Pitch::getPitchLabelForFrequency(adjFreqMax);
|
Chris@38
|
2345
|
Chris@38
|
2346 if (pmin != pmax) {
|
Chris@65
|
2347 adjPitchText = tr("Peak Pitch:\t%3 - %4\n").arg(pmin).arg(pmax);
|
Chris@38
|
2348 } else {
|
Chris@65
|
2349 adjPitchText = tr("Peak Pitch:\t%2\n").arg(pmin);
|
Chris@35
|
2350 }
|
Chris@35
|
2351
|
Chris@35
|
2352 } else {
|
Chris@35
|
2353
|
Chris@44
|
2354 if (!getYBinSourceRange(v, y, freqMin, freqMax)) return "";
|
Chris@35
|
2355 }
|
Chris@35
|
2356
|
Chris@25
|
2357 QString text;
|
Chris@25
|
2358
|
Chris@25
|
2359 if (rtMin != rtMax) {
|
Chris@25
|
2360 text += tr("Time:\t%1 - %2\n")
|
Chris@25
|
2361 .arg(rtMin.toText(true).c_str())
|
Chris@25
|
2362 .arg(rtMax.toText(true).c_str());
|
Chris@25
|
2363 } else {
|
Chris@25
|
2364 text += tr("Time:\t%1\n")
|
Chris@25
|
2365 .arg(rtMin.toText(true).c_str());
|
Chris@0
|
2366 }
|
Chris@0
|
2367
|
Chris@25
|
2368 if (freqMin != freqMax) {
|
Chris@65
|
2369 text += tr("%1Bin Frequency:\t%2 - %3 Hz\n%4Bin Pitch:\t%5 - %6\n")
|
Chris@65
|
2370 .arg(adjFreqText)
|
Chris@25
|
2371 .arg(freqMin)
|
Chris@25
|
2372 .arg(freqMax)
|
Chris@65
|
2373 .arg(adjPitchText)
|
Chris@65
|
2374 .arg(Pitch::getPitchLabelForFrequency(freqMin))
|
Chris@65
|
2375 .arg(Pitch::getPitchLabelForFrequency(freqMax));
|
Chris@65
|
2376 } else {
|
Chris@65
|
2377 text += tr("%1Bin Frequency:\t%2 Hz\n%3Bin Pitch:\t%4\n")
|
Chris@35
|
2378 .arg(adjFreqText)
|
Chris@25
|
2379 .arg(freqMin)
|
Chris@65
|
2380 .arg(adjPitchText)
|
Chris@65
|
2381 .arg(Pitch::getPitchLabelForFrequency(freqMin));
|
Chris@25
|
2382 }
|
Chris@25
|
2383
|
Chris@38
|
2384 if (haveValues) {
|
Chris@38
|
2385 float dbMin = AudioLevel::multiplier_to_dB(magMin);
|
Chris@38
|
2386 float dbMax = AudioLevel::multiplier_to_dB(magMax);
|
Chris@43
|
2387 QString dbMinString;
|
Chris@43
|
2388 QString dbMaxString;
|
Chris@43
|
2389 if (dbMin == AudioLevel::DB_FLOOR) {
|
Chris@43
|
2390 dbMinString = tr("-Inf");
|
Chris@43
|
2391 } else {
|
Chris@43
|
2392 dbMinString = QString("%1").arg(lrintf(dbMin));
|
Chris@43
|
2393 }
|
Chris@43
|
2394 if (dbMax == AudioLevel::DB_FLOOR) {
|
Chris@43
|
2395 dbMaxString = tr("-Inf");
|
Chris@43
|
2396 } else {
|
Chris@43
|
2397 dbMaxString = QString("%1").arg(lrintf(dbMax));
|
Chris@43
|
2398 }
|
Chris@25
|
2399 if (lrintf(dbMin) != lrintf(dbMax)) {
|
Chris@25
|
2400 text += tr("dB:\t%1 - %2").arg(lrintf(dbMin)).arg(lrintf(dbMax));
|
Chris@25
|
2401 } else {
|
Chris@25
|
2402 text += tr("dB:\t%1").arg(lrintf(dbMin));
|
Chris@25
|
2403 }
|
Chris@38
|
2404 if (phaseMin != phaseMax) {
|
Chris@38
|
2405 text += tr("\nPhase:\t%1 - %2").arg(phaseMin).arg(phaseMax);
|
Chris@38
|
2406 } else {
|
Chris@38
|
2407 text += tr("\nPhase:\t%1").arg(phaseMin);
|
Chris@38
|
2408 }
|
Chris@25
|
2409 }
|
Chris@25
|
2410
|
Chris@25
|
2411 return text;
|
Chris@0
|
2412 }
|
Chris@25
|
2413
|
Chris@0
|
2414 int
|
Chris@40
|
2415 SpectrogramLayer::getColourScaleWidth(QPainter &paint) const
|
Chris@40
|
2416 {
|
Chris@40
|
2417 int cw;
|
Chris@40
|
2418
|
Chris@119
|
2419 cw = paint.fontMetrics().width("-80dB");
|
Chris@119
|
2420
|
Chris@119
|
2421 /*!!!
|
Chris@40
|
2422 switch (m_colourScale) {
|
Chris@40
|
2423 default:
|
Chris@40
|
2424 case LinearColourScale:
|
Chris@40
|
2425 cw = paint.fontMetrics().width(QString("0.00"));
|
Chris@40
|
2426 break;
|
Chris@40
|
2427
|
Chris@40
|
2428 case MeterColourScale:
|
Chris@40
|
2429 case dBColourScale:
|
Chris@119
|
2430 case OtherColourScale:
|
Chris@40
|
2431 cw = std::max(paint.fontMetrics().width(tr("-Inf")),
|
Chris@40
|
2432 paint.fontMetrics().width(tr("-90")));
|
Chris@40
|
2433 break;
|
Chris@40
|
2434
|
Chris@40
|
2435 case PhaseColourScale:
|
Chris@40
|
2436 cw = paint.fontMetrics().width(QString("-") + QChar(0x3c0));
|
Chris@40
|
2437 break;
|
Chris@40
|
2438 }
|
Chris@119
|
2439 */
|
Chris@119
|
2440
|
Chris@40
|
2441
|
Chris@40
|
2442 return cw;
|
Chris@40
|
2443 }
|
Chris@40
|
2444
|
Chris@40
|
2445 int
|
Chris@44
|
2446 SpectrogramLayer::getVerticalScaleWidth(View *v, QPainter &paint) const
|
Chris@0
|
2447 {
|
Chris@0
|
2448 if (!m_model || !m_model->isOK()) return 0;
|
Chris@0
|
2449
|
Chris@40
|
2450 int cw = getColourScaleWidth(paint);
|
Chris@40
|
2451
|
Chris@0
|
2452 int tw = paint.fontMetrics().width(QString("%1")
|
Chris@0
|
2453 .arg(m_maxFrequency > 0 ?
|
Chris@0
|
2454 m_maxFrequency - 1 :
|
Chris@0
|
2455 m_model->getSampleRate() / 2));
|
Chris@0
|
2456
|
Chris@0
|
2457 int fw = paint.fontMetrics().width(QString("43Hz"));
|
Chris@0
|
2458 if (tw < fw) tw = fw;
|
Chris@40
|
2459
|
Chris@40
|
2460 int tickw = (m_frequencyScale == LogFrequencyScale ? 10 : 4);
|
Chris@0
|
2461
|
Chris@40
|
2462 return cw + tickw + tw + 13;
|
Chris@0
|
2463 }
|
Chris@0
|
2464
|
Chris@0
|
2465 void
|
Chris@44
|
2466 SpectrogramLayer::paintVerticalScale(View *v, QPainter &paint, QRect rect) const
|
Chris@0
|
2467 {
|
Chris@0
|
2468 if (!m_model || !m_model->isOK()) {
|
Chris@0
|
2469 return;
|
Chris@0
|
2470 }
|
Chris@0
|
2471
|
Chris@122
|
2472 Profiler profiler("SpectrogramLayer::paintVerticalScale", true);
|
Chris@122
|
2473
|
Chris@120
|
2474 //!!! cache this?
|
Chris@120
|
2475
|
Chris@0
|
2476 int h = rect.height(), w = rect.width();
|
Chris@0
|
2477
|
Chris@40
|
2478 int tickw = (m_frequencyScale == LogFrequencyScale ? 10 : 4);
|
Chris@40
|
2479 int pkw = (m_frequencyScale == LogFrequencyScale ? 10 : 0);
|
Chris@40
|
2480
|
Chris@107
|
2481 size_t bins = m_fftSize / 2;
|
Chris@0
|
2482 int sr = m_model->getSampleRate();
|
Chris@0
|
2483
|
Chris@0
|
2484 if (m_maxFrequency > 0) {
|
Chris@107
|
2485 bins = int((double(m_maxFrequency) * m_fftSize) / sr + 0.1);
|
Chris@107
|
2486 if (bins > m_fftSize / 2) bins = m_fftSize / 2;
|
Chris@0
|
2487 }
|
Chris@0
|
2488
|
Chris@40
|
2489 int cw = getColourScaleWidth(paint);
|
Chris@119
|
2490 int cbw = paint.fontMetrics().width("dB");
|
Chris@40
|
2491
|
Chris@0
|
2492 int py = -1;
|
Chris@0
|
2493 int textHeight = paint.fontMetrics().height();
|
Chris@0
|
2494 int toff = -textHeight + paint.fontMetrics().ascent() + 2;
|
Chris@0
|
2495
|
Chris@119
|
2496 if (h > textHeight * 3 + 10) {
|
Chris@119
|
2497
|
Chris@119
|
2498 int topLines = 2;
|
Chris@119
|
2499 if (m_colourScale == PhaseColourScale) topLines = 1;
|
Chris@119
|
2500
|
Chris@119
|
2501 int ch = h - textHeight * (topLines + 1) - 8;
|
Chris@119
|
2502 // paint.drawRect(4, textHeight + 4, cw - 1, ch + 1);
|
Chris@119
|
2503 paint.drawRect(4 + cw - cbw, textHeight * topLines + 4, cbw - 1, ch + 1);
|
Chris@40
|
2504
|
Chris@40
|
2505 QString top, bottom;
|
Chris@119
|
2506 /*!!!
|
Chris@40
|
2507 switch (m_colourScale) {
|
Chris@40
|
2508 default:
|
Chris@40
|
2509 case LinearColourScale:
|
Chris@40
|
2510 top = (m_normalizeColumns ? "1.0" : "0.02");
|
Chris@40
|
2511 bottom = (m_normalizeColumns ? "0.0" : "0.00");
|
Chris@40
|
2512 break;
|
Chris@40
|
2513
|
Chris@40
|
2514 case MeterColourScale:
|
Chris@40
|
2515 top = (m_normalizeColumns ? QString("0") :
|
Chris@40
|
2516 QString("%1").arg(int(AudioLevel::multiplier_to_dB(0.02))));
|
Chris@40
|
2517 bottom = QString("%1").
|
Chris@40
|
2518 arg(int(AudioLevel::multiplier_to_dB
|
Chris@40
|
2519 (AudioLevel::preview_to_multiplier(0, 255))));
|
Chris@40
|
2520 break;
|
Chris@40
|
2521
|
Chris@40
|
2522 case dBColourScale:
|
Chris@119
|
2523 case OtherColourScale:
|
Chris@40
|
2524 top = "0";
|
Chris@40
|
2525 bottom = "-80";
|
Chris@40
|
2526 break;
|
Chris@40
|
2527
|
Chris@40
|
2528 case PhaseColourScale:
|
Chris@40
|
2529 top = QChar(0x3c0);
|
Chris@40
|
2530 bottom = "-" + top;
|
Chris@40
|
2531 break;
|
Chris@40
|
2532 }
|
Chris@119
|
2533 */
|
Chris@119
|
2534 float min = m_viewMags[v].getMin();
|
Chris@119
|
2535 float max = m_viewMags[v].getMax();
|
Chris@119
|
2536
|
Chris@119
|
2537 float dBmin = AudioLevel::multiplier_to_dB(min);
|
Chris@119
|
2538 float dBmax = AudioLevel::multiplier_to_dB(max);
|
Chris@119
|
2539
|
Chris@120
|
2540 if (dBmax < -60.f) dBmax = -60.f;
|
Chris@120
|
2541 else top = QString("%1").arg(lrintf(dBmax));
|
Chris@120
|
2542
|
Chris@120
|
2543 if (dBmin < dBmax - 60.f) dBmin = dBmax - 60.f;
|
Chris@119
|
2544 bottom = QString("%1").arg(lrintf(dBmin));
|
Chris@119
|
2545
|
Chris@119
|
2546 //!!! & phase etc
|
Chris@119
|
2547
|
Chris@119
|
2548 if (m_colourScale != PhaseColourScale) {
|
Chris@119
|
2549 paint.drawText((cw + 6 - paint.fontMetrics().width("dBFS")) / 2,
|
Chris@119
|
2550 2 + textHeight + toff, "dBFS");
|
Chris@119
|
2551 }
|
Chris@119
|
2552
|
Chris@119
|
2553 // paint.drawText((cw + 6 - paint.fontMetrics().width(top)) / 2,
|
Chris@119
|
2554 paint.drawText(3 + cw - cbw - paint.fontMetrics().width(top),
|
Chris@119
|
2555 2 + textHeight * topLines + toff + textHeight/2, top);
|
Chris@119
|
2556
|
Chris@119
|
2557 paint.drawText(3 + cw - cbw - paint.fontMetrics().width(bottom),
|
Chris@119
|
2558 h + toff - 3 - textHeight/2, bottom);
|
Chris@40
|
2559
|
Chris@40
|
2560 paint.save();
|
Chris@40
|
2561 paint.setBrush(Qt::NoBrush);
|
Chris@119
|
2562
|
Chris@119
|
2563 int lasty = 0;
|
Chris@119
|
2564 int lastdb = 0;
|
Chris@119
|
2565
|
Chris@40
|
2566 for (int i = 0; i < ch; ++i) {
|
Chris@119
|
2567
|
Chris@119
|
2568 float dBval = dBmin + (((dBmax - dBmin) * i) / (ch - 1));
|
Chris@119
|
2569 int idb = int(dBval);
|
Chris@119
|
2570
|
Chris@119
|
2571 float value = AudioLevel::dB_to_multiplier(dBval);
|
Chris@119
|
2572 int colour = getDisplayValue(v, value * m_gain);
|
Chris@119
|
2573 /*
|
Chris@119
|
2574 float value = min + (((max - min) * i) / (ch - 1));
|
Chris@119
|
2575 if (value < m_threshold) value = 0.f;
|
Chris@119
|
2576 int colour = getDisplayValue(v, value * m_gain);
|
Chris@119
|
2577 */
|
Chris@119
|
2578 /*
|
Chris@119
|
2579 int colour = (i * 255) / ch + 1;
|
Chris@119
|
2580 */
|
Chris@119
|
2581 paint.setPen(m_colourMap.getColour(colour));
|
Chris@119
|
2582
|
Chris@119
|
2583 int y = textHeight * topLines + 4 + ch - i;
|
Chris@119
|
2584
|
Chris@119
|
2585 paint.drawLine(5 + cw - cbw, y, cw + 2, y);
|
Chris@119
|
2586
|
Chris@119
|
2587 // paint.drawLine(5, 4 + textHeight + ch - i,
|
Chris@119
|
2588 // cw + 2, 4 + textHeight + ch - i);
|
Chris@119
|
2589
|
Chris@119
|
2590
|
Chris@119
|
2591 if (i == 0) {
|
Chris@119
|
2592 lasty = y;
|
Chris@119
|
2593 lastdb = idb;
|
Chris@119
|
2594 } else if (i < ch - paint.fontMetrics().ascent() &&
|
Chris@120
|
2595 idb != lastdb &&
|
Chris@119
|
2596 ((abs(y - lasty) > textHeight &&
|
Chris@119
|
2597 idb % 10 == 0) ||
|
Chris@119
|
2598 (abs(y - lasty) > paint.fontMetrics().ascent() &&
|
Chris@119
|
2599 idb % 5 == 0))) {
|
Chris@119
|
2600 paint.setPen(Qt::black);
|
Chris@119
|
2601 QString text = QString("%1").arg(idb);
|
Chris@119
|
2602 paint.drawText(3 + cw - cbw - paint.fontMetrics().width(text),
|
Chris@119
|
2603 y + toff + textHeight/2, text);
|
Chris@119
|
2604 paint.setPen(Qt::white);
|
Chris@119
|
2605 paint.drawLine(5 + cw - cbw, y, 8 + cw - cbw, y);
|
Chris@119
|
2606 lasty = y;
|
Chris@119
|
2607 lastdb = idb;
|
Chris@119
|
2608 }
|
Chris@40
|
2609 }
|
Chris@40
|
2610 paint.restore();
|
Chris@40
|
2611 }
|
Chris@40
|
2612
|
Chris@40
|
2613 paint.drawLine(cw + 7, 0, cw + 7, h);
|
Chris@40
|
2614
|
Chris@0
|
2615 int bin = -1;
|
Chris@0
|
2616
|
Chris@44
|
2617 for (int y = 0; y < v->height(); ++y) {
|
Chris@0
|
2618
|
Chris@0
|
2619 float q0, q1;
|
Chris@44
|
2620 if (!getYBinRange(v, v->height() - y, q0, q1)) continue;
|
Chris@0
|
2621
|
Chris@0
|
2622 int vy;
|
Chris@0
|
2623
|
Chris@0
|
2624 if (int(q0) > bin) {
|
Chris@0
|
2625 vy = y;
|
Chris@0
|
2626 bin = int(q0);
|
Chris@0
|
2627 } else {
|
Chris@0
|
2628 continue;
|
Chris@0
|
2629 }
|
Chris@0
|
2630
|
Chris@107
|
2631 int freq = (sr * bin) / m_fftSize;
|
Chris@0
|
2632
|
Chris@0
|
2633 if (py >= 0 && (vy - py) < textHeight - 1) {
|
Chris@40
|
2634 if (m_frequencyScale == LinearFrequencyScale) {
|
Chris@40
|
2635 paint.drawLine(w - tickw, h - vy, w, h - vy);
|
Chris@40
|
2636 }
|
Chris@0
|
2637 continue;
|
Chris@0
|
2638 }
|
Chris@0
|
2639
|
Chris@0
|
2640 QString text = QString("%1").arg(freq);
|
Chris@40
|
2641 if (bin == 1) text = QString("%1Hz").arg(freq); // bin 0 is DC
|
Chris@40
|
2642 paint.drawLine(cw + 7, h - vy, w - pkw - 1, h - vy);
|
Chris@0
|
2643
|
Chris@0
|
2644 if (h - vy - textHeight >= -2) {
|
Chris@40
|
2645 int tx = w - 3 - paint.fontMetrics().width(text) - std::max(tickw, pkw);
|
Chris@0
|
2646 paint.drawText(tx, h - vy + toff, text);
|
Chris@0
|
2647 }
|
Chris@0
|
2648
|
Chris@0
|
2649 py = vy;
|
Chris@0
|
2650 }
|
Chris@40
|
2651
|
Chris@40
|
2652 if (m_frequencyScale == LogFrequencyScale) {
|
Chris@40
|
2653
|
Chris@40
|
2654 paint.drawLine(w - pkw - 1, 0, w - pkw - 1, h);
|
Chris@40
|
2655
|
Chris@110
|
2656 int sr = m_model->getSampleRate();
|
Chris@40
|
2657 float minf = getEffectiveMinFrequency();
|
Chris@40
|
2658 float maxf = getEffectiveMaxFrequency();
|
Chris@40
|
2659
|
Chris@122
|
2660 int py = h, ppy = h;
|
Chris@40
|
2661 paint.setBrush(paint.pen().color());
|
Chris@40
|
2662
|
Chris@40
|
2663 for (int i = 0; i < 128; ++i) {
|
Chris@40
|
2664
|
Chris@40
|
2665 float f = Pitch::getFrequencyForPitch(i);
|
Chris@44
|
2666 int y = lrintf(v->getYForFrequency(f, minf, maxf, true));
|
Chris@122
|
2667
|
Chris@122
|
2668 if (y < -2) break;
|
Chris@122
|
2669 if (y > h + 2) {
|
Chris@122
|
2670 continue;
|
Chris@122
|
2671 }
|
Chris@122
|
2672
|
Chris@40
|
2673 int n = (i % 12);
|
Chris@122
|
2674
|
Chris@122
|
2675 if (n == 1) {
|
Chris@122
|
2676 // C# -- fill the C from here
|
Chris@122
|
2677 if (ppy - y > 2) {
|
Chris@122
|
2678 paint.fillRect(w - pkw,
|
Chris@122
|
2679 // y - (py - y) / 2 - (py - y) / 4,
|
Chris@122
|
2680 y,
|
Chris@122
|
2681 pkw,
|
Chris@122
|
2682 (py + ppy) / 2 - y,
|
Chris@122
|
2683 // py - y + 1,
|
Chris@122
|
2684 Qt::gray);
|
Chris@122
|
2685 }
|
Chris@122
|
2686 }
|
Chris@122
|
2687
|
Chris@40
|
2688 if (n == 1 || n == 3 || n == 6 || n == 8 || n == 10) {
|
Chris@40
|
2689 // black notes
|
Chris@40
|
2690 paint.drawLine(w - pkw, y, w, y);
|
Chris@41
|
2691 int rh = ((py - y) / 4) * 2;
|
Chris@41
|
2692 if (rh < 2) rh = 2;
|
Chris@41
|
2693 paint.drawRect(w - pkw, y - (py-y)/4, pkw/2, rh);
|
Chris@40
|
2694 } else if (n == 0 || n == 5) {
|
Chris@122
|
2695 // C, F
|
Chris@40
|
2696 if (py < h) {
|
Chris@40
|
2697 paint.drawLine(w - pkw, (y + py) / 2, w, (y + py) / 2);
|
Chris@40
|
2698 }
|
Chris@40
|
2699 }
|
Chris@40
|
2700
|
Chris@122
|
2701 ppy = py;
|
Chris@40
|
2702 py = y;
|
Chris@40
|
2703 }
|
Chris@40
|
2704 }
|
Chris@0
|
2705 }
|
Chris@0
|
2706
|
Chris@6
|
2707 QString
|
Chris@6
|
2708 SpectrogramLayer::toXmlString(QString indent, QString extraAttributes) const
|
Chris@6
|
2709 {
|
Chris@6
|
2710 QString s;
|
Chris@6
|
2711
|
Chris@6
|
2712 s += QString("channel=\"%1\" "
|
Chris@6
|
2713 "windowSize=\"%2\" "
|
Chris@6
|
2714 "windowType=\"%3\" "
|
Chris@97
|
2715 "windowHopLevel=\"%4\" "
|
Chris@37
|
2716 "gain=\"%5\" "
|
Chris@37
|
2717 "threshold=\"%6\" ")
|
Chris@6
|
2718 .arg(m_channel)
|
Chris@6
|
2719 .arg(m_windowSize)
|
Chris@6
|
2720 .arg(m_windowType)
|
Chris@97
|
2721 .arg(m_windowHopLevel)
|
Chris@37
|
2722 .arg(m_gain)
|
Chris@37
|
2723 .arg(m_threshold);
|
Chris@37
|
2724
|
Chris@37
|
2725 s += QString("minFrequency=\"%1\" "
|
Chris@37
|
2726 "maxFrequency=\"%2\" "
|
Chris@37
|
2727 "colourScale=\"%3\" "
|
Chris@37
|
2728 "colourScheme=\"%4\" "
|
Chris@37
|
2729 "colourRotation=\"%5\" "
|
Chris@37
|
2730 "frequencyScale=\"%6\" "
|
Chris@37
|
2731 "binDisplay=\"%7\" "
|
Chris@37
|
2732 "normalizeColumns=\"%8\"")
|
Chris@37
|
2733 .arg(m_minFrequency)
|
Chris@6
|
2734 .arg(m_maxFrequency)
|
Chris@6
|
2735 .arg(m_colourScale)
|
Chris@6
|
2736 .arg(m_colourScheme)
|
Chris@37
|
2737 .arg(m_colourRotation)
|
Chris@35
|
2738 .arg(m_frequencyScale)
|
Chris@37
|
2739 .arg(m_binDisplay)
|
Chris@36
|
2740 .arg(m_normalizeColumns ? "true" : "false");
|
Chris@6
|
2741
|
Chris@6
|
2742 return Layer::toXmlString(indent, extraAttributes + " " + s);
|
Chris@6
|
2743 }
|
Chris@6
|
2744
|
Chris@11
|
2745 void
|
Chris@11
|
2746 SpectrogramLayer::setProperties(const QXmlAttributes &attributes)
|
Chris@11
|
2747 {
|
Chris@11
|
2748 bool ok = false;
|
Chris@11
|
2749
|
Chris@11
|
2750 int channel = attributes.value("channel").toInt(&ok);
|
Chris@11
|
2751 if (ok) setChannel(channel);
|
Chris@11
|
2752
|
Chris@11
|
2753 size_t windowSize = attributes.value("windowSize").toUInt(&ok);
|
Chris@11
|
2754 if (ok) setWindowSize(windowSize);
|
Chris@11
|
2755
|
Chris@11
|
2756 WindowType windowType = (WindowType)
|
Chris@11
|
2757 attributes.value("windowType").toInt(&ok);
|
Chris@11
|
2758 if (ok) setWindowType(windowType);
|
Chris@11
|
2759
|
Chris@97
|
2760 size_t windowHopLevel = attributes.value("windowHopLevel").toUInt(&ok);
|
Chris@97
|
2761 if (ok) setWindowHopLevel(windowHopLevel);
|
Chris@97
|
2762 else {
|
Chris@97
|
2763 size_t windowOverlap = attributes.value("windowOverlap").toUInt(&ok);
|
Chris@97
|
2764 // a percentage value
|
Chris@97
|
2765 if (ok) {
|
Chris@97
|
2766 if (windowOverlap == 0) setWindowHopLevel(0);
|
Chris@97
|
2767 else if (windowOverlap == 25) setWindowHopLevel(1);
|
Chris@97
|
2768 else if (windowOverlap == 50) setWindowHopLevel(2);
|
Chris@97
|
2769 else if (windowOverlap == 75) setWindowHopLevel(3);
|
Chris@97
|
2770 else if (windowOverlap == 90) setWindowHopLevel(4);
|
Chris@97
|
2771 }
|
Chris@97
|
2772 }
|
Chris@11
|
2773
|
Chris@11
|
2774 float gain = attributes.value("gain").toFloat(&ok);
|
Chris@11
|
2775 if (ok) setGain(gain);
|
Chris@11
|
2776
|
Chris@37
|
2777 float threshold = attributes.value("threshold").toFloat(&ok);
|
Chris@37
|
2778 if (ok) setThreshold(threshold);
|
Chris@37
|
2779
|
Chris@37
|
2780 size_t minFrequency = attributes.value("minFrequency").toUInt(&ok);
|
Chris@37
|
2781 if (ok) setMinFrequency(minFrequency);
|
Chris@37
|
2782
|
Chris@11
|
2783 size_t maxFrequency = attributes.value("maxFrequency").toUInt(&ok);
|
Chris@11
|
2784 if (ok) setMaxFrequency(maxFrequency);
|
Chris@11
|
2785
|
Chris@11
|
2786 ColourScale colourScale = (ColourScale)
|
Chris@11
|
2787 attributes.value("colourScale").toInt(&ok);
|
Chris@11
|
2788 if (ok) setColourScale(colourScale);
|
Chris@11
|
2789
|
Chris@11
|
2790 ColourScheme colourScheme = (ColourScheme)
|
Chris@11
|
2791 attributes.value("colourScheme").toInt(&ok);
|
Chris@11
|
2792 if (ok) setColourScheme(colourScheme);
|
Chris@11
|
2793
|
Chris@37
|
2794 int colourRotation = attributes.value("colourRotation").toInt(&ok);
|
Chris@37
|
2795 if (ok) setColourRotation(colourRotation);
|
Chris@37
|
2796
|
Chris@11
|
2797 FrequencyScale frequencyScale = (FrequencyScale)
|
Chris@11
|
2798 attributes.value("frequencyScale").toInt(&ok);
|
Chris@11
|
2799 if (ok) setFrequencyScale(frequencyScale);
|
Chris@35
|
2800
|
Chris@37
|
2801 BinDisplay binDisplay = (BinDisplay)
|
Chris@37
|
2802 attributes.value("binDisplay").toInt(&ok);
|
Chris@37
|
2803 if (ok) setBinDisplay(binDisplay);
|
Chris@36
|
2804
|
Chris@36
|
2805 bool normalizeColumns =
|
Chris@36
|
2806 (attributes.value("normalizeColumns").trimmed() == "true");
|
Chris@36
|
2807 setNormalizeColumns(normalizeColumns);
|
Chris@11
|
2808 }
|
Chris@11
|
2809
|
Chris@11
|
2810
|
Chris@0
|
2811 #ifdef INCLUDE_MOCFILES
|
Chris@0
|
2812 #include "SpectrogramLayer.moc.cpp"
|
Chris@0
|
2813 #endif
|
Chris@0
|
2814
|