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@484
|
7 This file copyright 2006-2009 Chris Cannam and QMUL.
|
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@167
|
24 #include "base/RangeMapper.h"
|
Chris@253
|
25 #include "base/LogRange.h"
|
Chris@376
|
26 #include "widgets/CommandHistory.h"
|
Chris@376
|
27 #include "ColourMapper.h"
|
Chris@283
|
28 #include "ImageRegionFinder.h"
|
Chris@484
|
29 #include "data/model/Dense3DModelPeakCache.h"
|
Chris@0
|
30
|
Chris@0
|
31 #include <QPainter>
|
Chris@0
|
32 #include <QImage>
|
Chris@0
|
33 #include <QPixmap>
|
Chris@0
|
34 #include <QRect>
|
Chris@0
|
35 #include <QTimer>
|
Chris@92
|
36 #include <QApplication>
|
Chris@178
|
37 #include <QMessageBox>
|
Chris@283
|
38 #include <QMouseEvent>
|
Chris@316
|
39 #include <QTextStream>
|
Chris@0
|
40
|
Chris@0
|
41 #include <iostream>
|
Chris@0
|
42
|
Chris@480
|
43 using std::cerr;
|
Chris@480
|
44 using std::endl;
|
Chris@0
|
45 #include <cassert>
|
Chris@0
|
46 #include <cmath>
|
Chris@0
|
47
|
Chris@486
|
48 #define DEBUG_SPECTROGRAM_REPAINT 1
|
Chris@0
|
49
|
Chris@44
|
50 SpectrogramLayer::SpectrogramLayer(Configuration config) :
|
Chris@0
|
51 m_model(0),
|
Chris@0
|
52 m_channel(0),
|
Chris@0
|
53 m_windowSize(1024),
|
Chris@0
|
54 m_windowType(HanningWindow),
|
Chris@97
|
55 m_windowHopLevel(2),
|
Chris@109
|
56 m_zeroPadLevel(0),
|
Chris@107
|
57 m_fftSize(1024),
|
Chris@0
|
58 m_gain(1.0),
|
Chris@215
|
59 m_initialGain(1.0),
|
Chris@37
|
60 m_threshold(0.0),
|
Chris@215
|
61 m_initialThreshold(0.0),
|
Chris@9
|
62 m_colourRotation(0),
|
Chris@215
|
63 m_initialRotation(0),
|
Chris@119
|
64 m_minFrequency(10),
|
Chris@0
|
65 m_maxFrequency(8000),
|
Chris@135
|
66 m_initialMaxFrequency(8000),
|
Chris@0
|
67 m_colourScale(dBColourScale),
|
Chris@197
|
68 m_colourMap(0),
|
Chris@0
|
69 m_frequencyScale(LinearFrequencyScale),
|
Chris@37
|
70 m_binDisplay(AllBins),
|
Chris@36
|
71 m_normalizeColumns(false),
|
Chris@120
|
72 m_normalizeVisibleArea(false),
|
Chris@133
|
73 m_lastEmittedZoomStep(-1),
|
Chris@390
|
74 m_synchronous(false),
|
Chris@215
|
75 m_lastPaintBlockWidth(0),
|
Chris@0
|
76 m_updateTimer(0),
|
Chris@44
|
77 m_candidateFillStartFrame(0),
|
Chris@193
|
78 m_exiting(false),
|
Chris@193
|
79 m_sliceableModel(0)
|
Chris@0
|
80 {
|
Chris@215
|
81 if (config == FullRangeDb) {
|
Chris@215
|
82 m_initialMaxFrequency = 0;
|
Chris@215
|
83 setMaxFrequency(0);
|
Chris@215
|
84 } else if (config == MelodicRange) {
|
Chris@0
|
85 setWindowSize(8192);
|
Chris@97
|
86 setWindowHopLevel(4);
|
Chris@215
|
87 m_initialMaxFrequency = 1500;
|
Chris@215
|
88 setMaxFrequency(1500);
|
Chris@215
|
89 setMinFrequency(40);
|
Chris@0
|
90 setColourScale(LinearColourScale);
|
Chris@215
|
91 setColourMap(ColourMapper::Sunset);
|
Chris@215
|
92 setFrequencyScale(LogFrequencyScale);
|
Chris@224
|
93 // setGain(20);
|
Chris@37
|
94 } else if (config == MelodicPeaks) {
|
Chris@37
|
95 setWindowSize(4096);
|
Chris@97
|
96 setWindowHopLevel(5);
|
Chris@135
|
97 m_initialMaxFrequency = 2000;
|
Chris@40
|
98 setMaxFrequency(2000);
|
Chris@37
|
99 setMinFrequency(40);
|
Chris@37
|
100 setFrequencyScale(LogFrequencyScale);
|
Chris@215
|
101 setColourScale(LinearColourScale);
|
Chris@37
|
102 setBinDisplay(PeakFrequencies);
|
Chris@37
|
103 setNormalizeColumns(true);
|
Chris@0
|
104 }
|
Chris@110
|
105
|
Chris@122
|
106 Preferences *prefs = Preferences::getInstance();
|
Chris@122
|
107 connect(prefs, SIGNAL(propertyChanged(PropertyContainer::PropertyName)),
|
Chris@122
|
108 this, SLOT(preferenceChanged(PropertyContainer::PropertyName)));
|
Chris@122
|
109 setWindowType(prefs->getWindowType());
|
Chris@122
|
110
|
Chris@197
|
111 initialisePalette();
|
Chris@0
|
112 }
|
Chris@0
|
113
|
Chris@0
|
114 SpectrogramLayer::~SpectrogramLayer()
|
Chris@0
|
115 {
|
Chris@0
|
116 delete m_updateTimer;
|
Chris@0
|
117 m_updateTimer = 0;
|
Chris@0
|
118
|
Chris@130
|
119 invalidateFFTModels();
|
Chris@0
|
120 }
|
Chris@0
|
121
|
Chris@0
|
122 void
|
Chris@0
|
123 SpectrogramLayer::setModel(const DenseTimeValueModel *model)
|
Chris@0
|
124 {
|
Chris@101
|
125 // std::cerr << "SpectrogramLayer(" << this << "): setModel(" << model << ")" << std::endl;
|
Chris@34
|
126
|
Chris@110
|
127 if (model == m_model) return;
|
Chris@110
|
128
|
Chris@0
|
129 m_model = model;
|
Chris@130
|
130 invalidateFFTModels();
|
Chris@0
|
131
|
Chris@0
|
132 if (!m_model || !m_model->isOK()) return;
|
Chris@0
|
133
|
Chris@320
|
134 connectSignals(m_model);
|
Chris@0
|
135
|
Chris@0
|
136 connect(m_model, SIGNAL(modelChanged()), this, SLOT(cacheInvalid()));
|
Chris@0
|
137 connect(m_model, SIGNAL(modelChanged(size_t, size_t)),
|
Chris@0
|
138 this, SLOT(cacheInvalid(size_t, size_t)));
|
Chris@0
|
139
|
Chris@0
|
140 emit modelReplaced();
|
Chris@110
|
141 }
|
Chris@115
|
142
|
Chris@0
|
143 Layer::PropertyList
|
Chris@0
|
144 SpectrogramLayer::getProperties() const
|
Chris@0
|
145 {
|
Chris@0
|
146 PropertyList list;
|
Chris@87
|
147 list.push_back("Colour");
|
Chris@87
|
148 list.push_back("Colour Scale");
|
Chris@87
|
149 list.push_back("Window Size");
|
Chris@97
|
150 list.push_back("Window Increment");
|
Chris@87
|
151 list.push_back("Normalize Columns");
|
Chris@120
|
152 list.push_back("Normalize Visible Area");
|
Chris@87
|
153 list.push_back("Bin Display");
|
Chris@87
|
154 list.push_back("Threshold");
|
Chris@87
|
155 list.push_back("Gain");
|
Chris@87
|
156 list.push_back("Colour Rotation");
|
Chris@153
|
157 // list.push_back("Min Frequency");
|
Chris@153
|
158 // list.push_back("Max Frequency");
|
Chris@87
|
159 list.push_back("Frequency Scale");
|
Chris@153
|
160 //// list.push_back("Zero Padding");
|
Chris@0
|
161 return list;
|
Chris@0
|
162 }
|
Chris@0
|
163
|
Chris@87
|
164 QString
|
Chris@87
|
165 SpectrogramLayer::getPropertyLabel(const PropertyName &name) const
|
Chris@87
|
166 {
|
Chris@87
|
167 if (name == "Colour") return tr("Colour");
|
Chris@87
|
168 if (name == "Colour Scale") return tr("Colour Scale");
|
Chris@87
|
169 if (name == "Window Size") return tr("Window Size");
|
Chris@112
|
170 if (name == "Window Increment") return tr("Window Overlap");
|
Chris@87
|
171 if (name == "Normalize Columns") return tr("Normalize Columns");
|
Chris@120
|
172 if (name == "Normalize Visible Area") return tr("Normalize Visible Area");
|
Chris@87
|
173 if (name == "Bin Display") return tr("Bin Display");
|
Chris@87
|
174 if (name == "Threshold") return tr("Threshold");
|
Chris@87
|
175 if (name == "Gain") return tr("Gain");
|
Chris@87
|
176 if (name == "Colour Rotation") return tr("Colour Rotation");
|
Chris@87
|
177 if (name == "Min Frequency") return tr("Min Frequency");
|
Chris@87
|
178 if (name == "Max Frequency") return tr("Max Frequency");
|
Chris@87
|
179 if (name == "Frequency Scale") return tr("Frequency Scale");
|
Chris@109
|
180 if (name == "Zero Padding") return tr("Smoothing");
|
Chris@87
|
181 return "";
|
Chris@87
|
182 }
|
Chris@87
|
183
|
Chris@335
|
184 QString
|
Chris@335
|
185 SpectrogramLayer::getPropertyIconName(const PropertyName &name) const
|
Chris@335
|
186 {
|
Chris@335
|
187 if (name == "Normalize Columns") return "normalise-columns";
|
Chris@335
|
188 if (name == "Normalize Visible Area") return "normalise";
|
Chris@335
|
189 return "";
|
Chris@335
|
190 }
|
Chris@335
|
191
|
Chris@0
|
192 Layer::PropertyType
|
Chris@0
|
193 SpectrogramLayer::getPropertyType(const PropertyName &name) const
|
Chris@0
|
194 {
|
Chris@87
|
195 if (name == "Gain") return RangeProperty;
|
Chris@87
|
196 if (name == "Colour Rotation") return RangeProperty;
|
Chris@87
|
197 if (name == "Normalize Columns") return ToggleProperty;
|
Chris@120
|
198 if (name == "Normalize Visible Area") return ToggleProperty;
|
Chris@87
|
199 if (name == "Threshold") return RangeProperty;
|
Chris@109
|
200 if (name == "Zero Padding") return ToggleProperty;
|
Chris@0
|
201 return ValueProperty;
|
Chris@0
|
202 }
|
Chris@0
|
203
|
Chris@0
|
204 QString
|
Chris@0
|
205 SpectrogramLayer::getPropertyGroupName(const PropertyName &name) const
|
Chris@0
|
206 {
|
Chris@153
|
207 if (name == "Bin Display" ||
|
Chris@153
|
208 name == "Frequency Scale") return tr("Bins");
|
Chris@87
|
209 if (name == "Window Size" ||
|
Chris@109
|
210 name == "Window Increment" ||
|
Chris@109
|
211 name == "Zero Padding") return tr("Window");
|
Chris@87
|
212 if (name == "Colour" ||
|
Chris@87
|
213 name == "Threshold" ||
|
Chris@87
|
214 name == "Colour Rotation") return tr("Colour");
|
Chris@87
|
215 if (name == "Normalize Columns" ||
|
Chris@120
|
216 name == "Normalize Visible Area" ||
|
Chris@153
|
217 name == "Gain" ||
|
Chris@87
|
218 name == "Colour Scale") return tr("Scale");
|
Chris@0
|
219 return QString();
|
Chris@0
|
220 }
|
Chris@0
|
221
|
Chris@0
|
222 int
|
Chris@0
|
223 SpectrogramLayer::getPropertyRangeAndValue(const PropertyName &name,
|
Chris@216
|
224 int *min, int *max, int *deflt) const
|
Chris@0
|
225 {
|
Chris@216
|
226 int val = 0;
|
Chris@216
|
227
|
Chris@216
|
228 int garbage0, garbage1, garbage2;
|
Chris@55
|
229 if (!min) min = &garbage0;
|
Chris@55
|
230 if (!max) max = &garbage1;
|
Chris@216
|
231 if (!deflt) deflt = &garbage2;
|
Chris@10
|
232
|
Chris@87
|
233 if (name == "Gain") {
|
Chris@0
|
234
|
Chris@0
|
235 *min = -50;
|
Chris@0
|
236 *max = 50;
|
Chris@0
|
237
|
Chris@216
|
238 *deflt = lrintf(log10(m_initialGain) * 20.0);;
|
Chris@216
|
239 if (*deflt < *min) *deflt = *min;
|
Chris@216
|
240 if (*deflt > *max) *deflt = *max;
|
Chris@216
|
241
|
Chris@216
|
242 val = lrintf(log10(m_gain) * 20.0);
|
Chris@216
|
243 if (val < *min) val = *min;
|
Chris@216
|
244 if (val > *max) val = *max;
|
Chris@0
|
245
|
Chris@87
|
246 } else if (name == "Threshold") {
|
Chris@37
|
247
|
Chris@37
|
248 *min = -50;
|
Chris@37
|
249 *max = 0;
|
Chris@37
|
250
|
Chris@216
|
251 *deflt = lrintf(AudioLevel::multiplier_to_dB(m_initialThreshold));
|
Chris@216
|
252 if (*deflt < *min) *deflt = *min;
|
Chris@216
|
253 if (*deflt > *max) *deflt = *max;
|
Chris@216
|
254
|
Chris@216
|
255 val = lrintf(AudioLevel::multiplier_to_dB(m_threshold));
|
Chris@216
|
256 if (val < *min) val = *min;
|
Chris@216
|
257 if (val > *max) val = *max;
|
Chris@37
|
258
|
Chris@87
|
259 } else if (name == "Colour Rotation") {
|
Chris@9
|
260
|
Chris@9
|
261 *min = 0;
|
Chris@9
|
262 *max = 256;
|
Chris@216
|
263 *deflt = m_initialRotation;
|
Chris@216
|
264
|
Chris@216
|
265 val = m_colourRotation;
|
Chris@9
|
266
|
Chris@87
|
267 } else if (name == "Colour Scale") {
|
Chris@0
|
268
|
Chris@0
|
269 *min = 0;
|
Chris@176
|
270 *max = 4;
|
Chris@216
|
271 *deflt = int(dBColourScale);
|
Chris@216
|
272
|
Chris@216
|
273 val = (int)m_colourScale;
|
Chris@0
|
274
|
Chris@87
|
275 } else if (name == "Colour") {
|
Chris@0
|
276
|
Chris@0
|
277 *min = 0;
|
Chris@196
|
278 *max = ColourMapper::getColourMapCount() - 1;
|
Chris@216
|
279 *deflt = 0;
|
Chris@216
|
280
|
Chris@216
|
281 val = m_colourMap;
|
Chris@0
|
282
|
Chris@87
|
283 } else if (name == "Window Size") {
|
Chris@0
|
284
|
Chris@0
|
285 *min = 0;
|
Chris@0
|
286 *max = 10;
|
Chris@216
|
287 *deflt = 5;
|
Chris@0
|
288
|
Chris@216
|
289 val = 0;
|
Chris@0
|
290 int ws = m_windowSize;
|
Chris@216
|
291 while (ws > 32) { ws >>= 1; val ++; }
|
Chris@0
|
292
|
Chris@97
|
293 } else if (name == "Window Increment") {
|
Chris@0
|
294
|
Chris@0
|
295 *min = 0;
|
Chris@97
|
296 *max = 5;
|
Chris@216
|
297 *deflt = 2;
|
Chris@216
|
298
|
Chris@216
|
299 val = m_windowHopLevel;
|
Chris@0
|
300
|
Chris@109
|
301 } else if (name == "Zero Padding") {
|
Chris@109
|
302
|
Chris@109
|
303 *min = 0;
|
Chris@109
|
304 *max = 1;
|
Chris@216
|
305 *deflt = 0;
|
Chris@109
|
306
|
Chris@216
|
307 val = m_zeroPadLevel > 0 ? 1 : 0;
|
Chris@109
|
308
|
Chris@87
|
309 } else if (name == "Min Frequency") {
|
Chris@37
|
310
|
Chris@37
|
311 *min = 0;
|
Chris@37
|
312 *max = 9;
|
Chris@216
|
313 *deflt = 1;
|
Chris@37
|
314
|
Chris@37
|
315 switch (m_minFrequency) {
|
Chris@216
|
316 case 0: default: val = 0; break;
|
Chris@216
|
317 case 10: val = 1; break;
|
Chris@216
|
318 case 20: val = 2; break;
|
Chris@216
|
319 case 40: val = 3; break;
|
Chris@216
|
320 case 100: val = 4; break;
|
Chris@216
|
321 case 250: val = 5; break;
|
Chris@216
|
322 case 500: val = 6; break;
|
Chris@216
|
323 case 1000: val = 7; break;
|
Chris@216
|
324 case 4000: val = 8; break;
|
Chris@216
|
325 case 10000: val = 9; break;
|
Chris@37
|
326 }
|
Chris@37
|
327
|
Chris@87
|
328 } else if (name == "Max Frequency") {
|
Chris@0
|
329
|
Chris@0
|
330 *min = 0;
|
Chris@0
|
331 *max = 9;
|
Chris@216
|
332 *deflt = 6;
|
Chris@0
|
333
|
Chris@0
|
334 switch (m_maxFrequency) {
|
Chris@216
|
335 case 500: val = 0; break;
|
Chris@216
|
336 case 1000: val = 1; break;
|
Chris@216
|
337 case 1500: val = 2; break;
|
Chris@216
|
338 case 2000: val = 3; break;
|
Chris@216
|
339 case 4000: val = 4; break;
|
Chris@216
|
340 case 6000: val = 5; break;
|
Chris@216
|
341 case 8000: val = 6; break;
|
Chris@216
|
342 case 12000: val = 7; break;
|
Chris@216
|
343 case 16000: val = 8; break;
|
Chris@216
|
344 default: val = 9; break;
|
Chris@0
|
345 }
|
Chris@0
|
346
|
Chris@87
|
347 } else if (name == "Frequency Scale") {
|
Chris@0
|
348
|
Chris@0
|
349 *min = 0;
|
Chris@0
|
350 *max = 1;
|
Chris@216
|
351 *deflt = int(LinearFrequencyScale);
|
Chris@216
|
352 val = (int)m_frequencyScale;
|
Chris@0
|
353
|
Chris@87
|
354 } else if (name == "Bin Display") {
|
Chris@35
|
355
|
Chris@35
|
356 *min = 0;
|
Chris@35
|
357 *max = 2;
|
Chris@216
|
358 *deflt = int(AllBins);
|
Chris@216
|
359 val = (int)m_binDisplay;
|
Chris@35
|
360
|
Chris@87
|
361 } else if (name == "Normalize Columns") {
|
Chris@36
|
362
|
Chris@216
|
363 *deflt = 0;
|
Chris@216
|
364 val = (m_normalizeColumns ? 1 : 0);
|
Chris@36
|
365
|
Chris@120
|
366 } else if (name == "Normalize Visible Area") {
|
Chris@120
|
367
|
Chris@216
|
368 *deflt = 0;
|
Chris@216
|
369 val = (m_normalizeVisibleArea ? 1 : 0);
|
Chris@120
|
370
|
Chris@0
|
371 } else {
|
Chris@216
|
372 val = Layer::getPropertyRangeAndValue(name, min, max, deflt);
|
Chris@0
|
373 }
|
Chris@0
|
374
|
Chris@216
|
375 return val;
|
Chris@0
|
376 }
|
Chris@0
|
377
|
Chris@0
|
378 QString
|
Chris@0
|
379 SpectrogramLayer::getPropertyValueLabel(const PropertyName &name,
|
Chris@9
|
380 int value) const
|
Chris@0
|
381 {
|
Chris@87
|
382 if (name == "Colour") {
|
Chris@196
|
383 return ColourMapper::getColourMapName(value);
|
Chris@0
|
384 }
|
Chris@87
|
385 if (name == "Colour Scale") {
|
Chris@0
|
386 switch (value) {
|
Chris@0
|
387 default:
|
Chris@37
|
388 case 0: return tr("Linear");
|
Chris@37
|
389 case 1: return tr("Meter");
|
Chris@215
|
390 case 2: return tr("dBV^2");
|
Chris@215
|
391 case 3: return tr("dBV");
|
Chris@119
|
392 case 4: return tr("Phase");
|
Chris@0
|
393 }
|
Chris@0
|
394 }
|
Chris@87
|
395 if (name == "Window Size") {
|
Chris@0
|
396 return QString("%1").arg(32 << value);
|
Chris@0
|
397 }
|
Chris@97
|
398 if (name == "Window Increment") {
|
Chris@0
|
399 switch (value) {
|
Chris@0
|
400 default:
|
Chris@112
|
401 case 0: return tr("None");
|
Chris@112
|
402 case 1: return tr("25 %");
|
Chris@112
|
403 case 2: return tr("50 %");
|
Chris@112
|
404 case 3: return tr("75 %");
|
Chris@112
|
405 case 4: return tr("87.5 %");
|
Chris@112
|
406 case 5: return tr("93.75 %");
|
Chris@0
|
407 }
|
Chris@0
|
408 }
|
Chris@109
|
409 if (name == "Zero Padding") {
|
Chris@109
|
410 if (value == 0) return tr("None");
|
Chris@109
|
411 return QString("%1x").arg(value + 1);
|
Chris@109
|
412 }
|
Chris@87
|
413 if (name == "Min Frequency") {
|
Chris@37
|
414 switch (value) {
|
Chris@37
|
415 default:
|
Chris@38
|
416 case 0: return tr("No min");
|
Chris@37
|
417 case 1: return tr("10 Hz");
|
Chris@37
|
418 case 2: return tr("20 Hz");
|
Chris@37
|
419 case 3: return tr("40 Hz");
|
Chris@37
|
420 case 4: return tr("100 Hz");
|
Chris@37
|
421 case 5: return tr("250 Hz");
|
Chris@37
|
422 case 6: return tr("500 Hz");
|
Chris@37
|
423 case 7: return tr("1 KHz");
|
Chris@37
|
424 case 8: return tr("4 KHz");
|
Chris@37
|
425 case 9: return tr("10 KHz");
|
Chris@37
|
426 }
|
Chris@37
|
427 }
|
Chris@87
|
428 if (name == "Max Frequency") {
|
Chris@0
|
429 switch (value) {
|
Chris@0
|
430 default:
|
Chris@0
|
431 case 0: return tr("500 Hz");
|
Chris@0
|
432 case 1: return tr("1 KHz");
|
Chris@0
|
433 case 2: return tr("1.5 KHz");
|
Chris@0
|
434 case 3: return tr("2 KHz");
|
Chris@0
|
435 case 4: return tr("4 KHz");
|
Chris@0
|
436 case 5: return tr("6 KHz");
|
Chris@0
|
437 case 6: return tr("8 KHz");
|
Chris@0
|
438 case 7: return tr("12 KHz");
|
Chris@0
|
439 case 8: return tr("16 KHz");
|
Chris@38
|
440 case 9: return tr("No max");
|
Chris@0
|
441 }
|
Chris@0
|
442 }
|
Chris@87
|
443 if (name == "Frequency Scale") {
|
Chris@0
|
444 switch (value) {
|
Chris@0
|
445 default:
|
Chris@0
|
446 case 0: return tr("Linear");
|
Chris@0
|
447 case 1: return tr("Log");
|
Chris@0
|
448 }
|
Chris@0
|
449 }
|
Chris@87
|
450 if (name == "Bin Display") {
|
Chris@35
|
451 switch (value) {
|
Chris@35
|
452 default:
|
Chris@37
|
453 case 0: return tr("All Bins");
|
Chris@37
|
454 case 1: return tr("Peak Bins");
|
Chris@37
|
455 case 2: return tr("Frequencies");
|
Chris@35
|
456 }
|
Chris@35
|
457 }
|
Chris@0
|
458 return tr("<unknown>");
|
Chris@0
|
459 }
|
Chris@0
|
460
|
Chris@167
|
461 RangeMapper *
|
Chris@167
|
462 SpectrogramLayer::getNewPropertyRangeMapper(const PropertyName &name) const
|
Chris@167
|
463 {
|
Chris@167
|
464 if (name == "Gain") {
|
Chris@167
|
465 return new LinearRangeMapper(-50, 50, -25, 25, tr("dB"));
|
Chris@167
|
466 }
|
Chris@167
|
467 if (name == "Threshold") {
|
Chris@167
|
468 return new LinearRangeMapper(-50, 0, -50, 0, tr("dB"));
|
Chris@167
|
469 }
|
Chris@167
|
470 return 0;
|
Chris@167
|
471 }
|
Chris@167
|
472
|
Chris@0
|
473 void
|
Chris@0
|
474 SpectrogramLayer::setProperty(const PropertyName &name, int value)
|
Chris@0
|
475 {
|
Chris@87
|
476 if (name == "Gain") {
|
Chris@0
|
477 setGain(pow(10, float(value)/20.0));
|
Chris@87
|
478 } else if (name == "Threshold") {
|
Chris@37
|
479 if (value == -50) setThreshold(0.0);
|
Chris@37
|
480 else setThreshold(AudioLevel::dB_to_multiplier(value));
|
Chris@87
|
481 } else if (name == "Colour Rotation") {
|
Chris@9
|
482 setColourRotation(value);
|
Chris@87
|
483 } else if (name == "Colour") {
|
Chris@197
|
484 setColourMap(value);
|
Chris@87
|
485 } else if (name == "Window Size") {
|
Chris@0
|
486 setWindowSize(32 << value);
|
Chris@97
|
487 } else if (name == "Window Increment") {
|
Chris@97
|
488 setWindowHopLevel(value);
|
Chris@109
|
489 } else if (name == "Zero Padding") {
|
Chris@109
|
490 setZeroPadLevel(value > 0.1 ? 3 : 0);
|
Chris@87
|
491 } else if (name == "Min Frequency") {
|
Chris@37
|
492 switch (value) {
|
Chris@37
|
493 default:
|
Chris@37
|
494 case 0: setMinFrequency(0); break;
|
Chris@37
|
495 case 1: setMinFrequency(10); break;
|
Chris@37
|
496 case 2: setMinFrequency(20); break;
|
Chris@37
|
497 case 3: setMinFrequency(40); break;
|
Chris@37
|
498 case 4: setMinFrequency(100); break;
|
Chris@37
|
499 case 5: setMinFrequency(250); break;
|
Chris@37
|
500 case 6: setMinFrequency(500); break;
|
Chris@37
|
501 case 7: setMinFrequency(1000); break;
|
Chris@37
|
502 case 8: setMinFrequency(4000); break;
|
Chris@37
|
503 case 9: setMinFrequency(10000); break;
|
Chris@37
|
504 }
|
Chris@133
|
505 int vs = getCurrentVerticalZoomStep();
|
Chris@133
|
506 if (vs != m_lastEmittedZoomStep) {
|
Chris@133
|
507 emit verticalZoomChanged();
|
Chris@133
|
508 m_lastEmittedZoomStep = vs;
|
Chris@133
|
509 }
|
Chris@87
|
510 } else if (name == "Max Frequency") {
|
Chris@0
|
511 switch (value) {
|
Chris@0
|
512 case 0: setMaxFrequency(500); break;
|
Chris@0
|
513 case 1: setMaxFrequency(1000); break;
|
Chris@0
|
514 case 2: setMaxFrequency(1500); break;
|
Chris@0
|
515 case 3: setMaxFrequency(2000); break;
|
Chris@0
|
516 case 4: setMaxFrequency(4000); break;
|
Chris@0
|
517 case 5: setMaxFrequency(6000); break;
|
Chris@0
|
518 case 6: setMaxFrequency(8000); break;
|
Chris@0
|
519 case 7: setMaxFrequency(12000); break;
|
Chris@0
|
520 case 8: setMaxFrequency(16000); break;
|
Chris@0
|
521 default:
|
Chris@0
|
522 case 9: setMaxFrequency(0); break;
|
Chris@0
|
523 }
|
Chris@133
|
524 int vs = getCurrentVerticalZoomStep();
|
Chris@133
|
525 if (vs != m_lastEmittedZoomStep) {
|
Chris@133
|
526 emit verticalZoomChanged();
|
Chris@133
|
527 m_lastEmittedZoomStep = vs;
|
Chris@133
|
528 }
|
Chris@87
|
529 } else if (name == "Colour Scale") {
|
Chris@0
|
530 switch (value) {
|
Chris@0
|
531 default:
|
Chris@0
|
532 case 0: setColourScale(LinearColourScale); break;
|
Chris@0
|
533 case 1: setColourScale(MeterColourScale); break;
|
Chris@215
|
534 case 2: setColourScale(dBSquaredColourScale); break;
|
Chris@215
|
535 case 3: setColourScale(dBColourScale); break;
|
Chris@119
|
536 case 4: setColourScale(PhaseColourScale); break;
|
Chris@0
|
537 }
|
Chris@87
|
538 } else if (name == "Frequency Scale") {
|
Chris@0
|
539 switch (value) {
|
Chris@0
|
540 default:
|
Chris@0
|
541 case 0: setFrequencyScale(LinearFrequencyScale); break;
|
Chris@0
|
542 case 1: setFrequencyScale(LogFrequencyScale); break;
|
Chris@0
|
543 }
|
Chris@87
|
544 } else if (name == "Bin Display") {
|
Chris@35
|
545 switch (value) {
|
Chris@35
|
546 default:
|
Chris@37
|
547 case 0: setBinDisplay(AllBins); break;
|
Chris@37
|
548 case 1: setBinDisplay(PeakBins); break;
|
Chris@37
|
549 case 2: setBinDisplay(PeakFrequencies); break;
|
Chris@35
|
550 }
|
Chris@82
|
551 } else if (name == "Normalize Columns") {
|
Chris@36
|
552 setNormalizeColumns(value ? true : false);
|
Chris@120
|
553 } else if (name == "Normalize Visible Area") {
|
Chris@120
|
554 setNormalizeVisibleArea(value ? true : false);
|
Chris@0
|
555 }
|
Chris@0
|
556 }
|
Chris@0
|
557
|
Chris@0
|
558 void
|
Chris@478
|
559 SpectrogramLayer::invalidateImageCaches()
|
Chris@95
|
560 {
|
Chris@478
|
561 for (ViewImageCache::iterator i = m_imageCaches.begin();
|
Chris@478
|
562 i != m_imageCaches.end(); ++i) {
|
Chris@95
|
563 i->second.validArea = QRect();
|
Chris@95
|
564 }
|
Chris@95
|
565 }
|
Chris@95
|
566
|
Chris@95
|
567 void
|
Chris@478
|
568 SpectrogramLayer::invalidateImageCaches(size_t startFrame, size_t endFrame)
|
Chris@95
|
569 {
|
Chris@478
|
570 for (ViewImageCache::iterator i = m_imageCaches.begin();
|
Chris@478
|
571 i != m_imageCaches.end(); ++i) {
|
Chris@131
|
572
|
Chris@95
|
573 //!!! when are views removed from the map? on setLayerDormant?
|
Chris@95
|
574 const View *v = i->first;
|
Chris@95
|
575
|
Chris@391
|
576 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@478
|
577 std::cerr << "SpectrogramLayer::invalidateImageCaches("
|
Chris@391
|
578 << startFrame << ", " << endFrame << "): view range is "
|
Chris@391
|
579 << v->getStartFrame() << ", " << v->getEndFrame()
|
Chris@391
|
580 << std::endl;
|
Chris@391
|
581
|
Chris@391
|
582 std::cerr << "Valid area was: " << i->second.validArea.x() << ", "
|
Chris@391
|
583 << i->second.validArea.y() << " "
|
Chris@391
|
584 << i->second.validArea.width() << "x"
|
Chris@391
|
585 << i->second.validArea.height() << std::endl;
|
Chris@391
|
586 #endif
|
Chris@391
|
587
|
Chris@391
|
588 if (long(startFrame) > v->getStartFrame()) {
|
Chris@391
|
589 if (startFrame >= v->getEndFrame()) {
|
Chris@391
|
590 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@391
|
591 std::cerr << "Modified start frame is off right of view" << std::endl;
|
Chris@391
|
592 #endif
|
Chris@391
|
593 return;
|
Chris@391
|
594 }
|
Chris@391
|
595 int x = v->getXForFrame(startFrame);
|
Chris@407
|
596 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@391
|
597 std::cerr << "clipping from 0 to " << x-1 << std::endl;
|
Chris@407
|
598 #endif
|
Chris@391
|
599 if (x > 1) {
|
Chris@391
|
600 i->second.validArea &=
|
Chris@391
|
601 QRect(0, 0, x-1, v->height());
|
Chris@391
|
602 } else {
|
Chris@391
|
603 i->second.validArea = QRect();
|
Chris@391
|
604 }
|
Chris@391
|
605 } else {
|
Chris@391
|
606 if (long(endFrame) < v->getStartFrame()) {
|
Chris@391
|
607 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@391
|
608 std::cerr << "Modified end frame is off left of view" << std::endl;
|
Chris@391
|
609 #endif
|
Chris@391
|
610 return;
|
Chris@391
|
611 }
|
Chris@391
|
612 int x = v->getXForFrame(endFrame);
|
Chris@391
|
613 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@391
|
614 std::cerr << "clipping from " << x+1 << " to " << v->width()
|
Chris@391
|
615 << std::endl;
|
Chris@391
|
616 #endif
|
Chris@391
|
617 if (x < v->width()) {
|
Chris@391
|
618 i->second.validArea &=
|
Chris@391
|
619 QRect(x+1, 0, v->width()-(x+1), v->height());
|
Chris@391
|
620 } else {
|
Chris@391
|
621 i->second.validArea = QRect();
|
Chris@391
|
622 }
|
Chris@95
|
623 }
|
Chris@391
|
624
|
Chris@391
|
625 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@391
|
626 std::cerr << "Valid area is now: " << i->second.validArea.x() << ", "
|
Chris@391
|
627 << i->second.validArea.y() << " "
|
Chris@391
|
628 << i->second.validArea.width() << "x"
|
Chris@391
|
629 << i->second.validArea.height() << std::endl;
|
Chris@391
|
630 #endif
|
Chris@95
|
631 }
|
Chris@95
|
632 }
|
Chris@95
|
633
|
Chris@95
|
634 void
|
Chris@122
|
635 SpectrogramLayer::preferenceChanged(PropertyContainer::PropertyName name)
|
Chris@122
|
636 {
|
Chris@122
|
637 std::cerr << "SpectrogramLayer::preferenceChanged(" << name.toStdString() << ")" << std::endl;
|
Chris@122
|
638
|
Chris@122
|
639 if (name == "Window Type") {
|
Chris@122
|
640 setWindowType(Preferences::getInstance()->getWindowType());
|
Chris@122
|
641 return;
|
Chris@122
|
642 }
|
Chris@221
|
643 if (name == "Spectrogram Smoothing") {
|
Chris@478
|
644 invalidateImageCaches();
|
Chris@122
|
645 invalidateMagnitudes();
|
Chris@122
|
646 emit layerParametersChanged();
|
Chris@122
|
647 }
|
Chris@122
|
648 if (name == "Tuning Frequency") {
|
Chris@122
|
649 emit layerParametersChanged();
|
Chris@122
|
650 }
|
Chris@122
|
651 }
|
Chris@122
|
652
|
Chris@122
|
653 void
|
Chris@0
|
654 SpectrogramLayer::setChannel(int ch)
|
Chris@0
|
655 {
|
Chris@0
|
656 if (m_channel == ch) return;
|
Chris@0
|
657
|
Chris@478
|
658 invalidateImageCaches();
|
Chris@0
|
659 m_channel = ch;
|
Chris@130
|
660 invalidateFFTModels();
|
Chris@9
|
661
|
Chris@0
|
662 emit layerParametersChanged();
|
Chris@0
|
663 }
|
Chris@0
|
664
|
Chris@0
|
665 int
|
Chris@0
|
666 SpectrogramLayer::getChannel() const
|
Chris@0
|
667 {
|
Chris@0
|
668 return m_channel;
|
Chris@0
|
669 }
|
Chris@0
|
670
|
Chris@0
|
671 void
|
Chris@0
|
672 SpectrogramLayer::setWindowSize(size_t ws)
|
Chris@0
|
673 {
|
Chris@0
|
674 if (m_windowSize == ws) return;
|
Chris@0
|
675
|
Chris@478
|
676 invalidateImageCaches();
|
Chris@0
|
677
|
Chris@0
|
678 m_windowSize = ws;
|
Chris@109
|
679 m_fftSize = ws * (m_zeroPadLevel + 1);
|
Chris@0
|
680
|
Chris@130
|
681 invalidateFFTModels();
|
Chris@9
|
682
|
Chris@9
|
683 emit layerParametersChanged();
|
Chris@0
|
684 }
|
Chris@0
|
685
|
Chris@0
|
686 size_t
|
Chris@0
|
687 SpectrogramLayer::getWindowSize() const
|
Chris@0
|
688 {
|
Chris@0
|
689 return m_windowSize;
|
Chris@0
|
690 }
|
Chris@0
|
691
|
Chris@0
|
692 void
|
Chris@97
|
693 SpectrogramLayer::setWindowHopLevel(size_t v)
|
Chris@0
|
694 {
|
Chris@97
|
695 if (m_windowHopLevel == v) return;
|
Chris@0
|
696
|
Chris@478
|
697 invalidateImageCaches();
|
Chris@0
|
698
|
Chris@97
|
699 m_windowHopLevel = v;
|
Chris@0
|
700
|
Chris@130
|
701 invalidateFFTModels();
|
Chris@9
|
702
|
Chris@9
|
703 emit layerParametersChanged();
|
Chris@9
|
704
|
Chris@110
|
705 // fillCache();
|
Chris@0
|
706 }
|
Chris@0
|
707
|
Chris@0
|
708 size_t
|
Chris@97
|
709 SpectrogramLayer::getWindowHopLevel() const
|
Chris@0
|
710 {
|
Chris@97
|
711 return m_windowHopLevel;
|
Chris@0
|
712 }
|
Chris@0
|
713
|
Chris@0
|
714 void
|
Chris@109
|
715 SpectrogramLayer::setZeroPadLevel(size_t v)
|
Chris@109
|
716 {
|
Chris@109
|
717 if (m_zeroPadLevel == v) return;
|
Chris@109
|
718
|
Chris@478
|
719 invalidateImageCaches();
|
Chris@109
|
720
|
Chris@109
|
721 m_zeroPadLevel = v;
|
Chris@109
|
722 m_fftSize = m_windowSize * (v + 1);
|
Chris@110
|
723
|
Chris@130
|
724 invalidateFFTModels();
|
Chris@109
|
725
|
Chris@109
|
726 emit layerParametersChanged();
|
Chris@109
|
727 }
|
Chris@109
|
728
|
Chris@109
|
729 size_t
|
Chris@109
|
730 SpectrogramLayer::getZeroPadLevel() const
|
Chris@109
|
731 {
|
Chris@109
|
732 return m_zeroPadLevel;
|
Chris@109
|
733 }
|
Chris@109
|
734
|
Chris@109
|
735 void
|
Chris@0
|
736 SpectrogramLayer::setWindowType(WindowType w)
|
Chris@0
|
737 {
|
Chris@0
|
738 if (m_windowType == w) return;
|
Chris@0
|
739
|
Chris@478
|
740 invalidateImageCaches();
|
Chris@0
|
741
|
Chris@0
|
742 m_windowType = w;
|
Chris@110
|
743
|
Chris@130
|
744 invalidateFFTModels();
|
Chris@9
|
745
|
Chris@9
|
746 emit layerParametersChanged();
|
Chris@0
|
747 }
|
Chris@0
|
748
|
Chris@0
|
749 WindowType
|
Chris@0
|
750 SpectrogramLayer::getWindowType() const
|
Chris@0
|
751 {
|
Chris@0
|
752 return m_windowType;
|
Chris@0
|
753 }
|
Chris@0
|
754
|
Chris@0
|
755 void
|
Chris@0
|
756 SpectrogramLayer::setGain(float gain)
|
Chris@0
|
757 {
|
Chris@101
|
758 // std::cerr << "SpectrogramLayer::setGain(" << gain << ") (my gain is now "
|
Chris@101
|
759 // << m_gain << ")" << std::endl;
|
Chris@55
|
760
|
Chris@40
|
761 if (m_gain == gain) return;
|
Chris@0
|
762
|
Chris@478
|
763 invalidateImageCaches();
|
Chris@0
|
764
|
Chris@0
|
765 m_gain = gain;
|
Chris@0
|
766
|
Chris@9
|
767 emit layerParametersChanged();
|
Chris@0
|
768 }
|
Chris@0
|
769
|
Chris@0
|
770 float
|
Chris@0
|
771 SpectrogramLayer::getGain() const
|
Chris@0
|
772 {
|
Chris@0
|
773 return m_gain;
|
Chris@0
|
774 }
|
Chris@0
|
775
|
Chris@0
|
776 void
|
Chris@37
|
777 SpectrogramLayer::setThreshold(float threshold)
|
Chris@37
|
778 {
|
Chris@40
|
779 if (m_threshold == threshold) return;
|
Chris@37
|
780
|
Chris@478
|
781 invalidateImageCaches();
|
Chris@37
|
782
|
Chris@37
|
783 m_threshold = threshold;
|
Chris@37
|
784
|
Chris@37
|
785 emit layerParametersChanged();
|
Chris@37
|
786 }
|
Chris@37
|
787
|
Chris@37
|
788 float
|
Chris@37
|
789 SpectrogramLayer::getThreshold() const
|
Chris@37
|
790 {
|
Chris@37
|
791 return m_threshold;
|
Chris@37
|
792 }
|
Chris@37
|
793
|
Chris@37
|
794 void
|
Chris@37
|
795 SpectrogramLayer::setMinFrequency(size_t mf)
|
Chris@37
|
796 {
|
Chris@37
|
797 if (m_minFrequency == mf) return;
|
Chris@37
|
798
|
Chris@248
|
799 // std::cerr << "SpectrogramLayer::setMinFrequency: " << mf << std::endl;
|
Chris@187
|
800
|
Chris@478
|
801 invalidateImageCaches();
|
Chris@119
|
802 invalidateMagnitudes();
|
Chris@37
|
803
|
Chris@37
|
804 m_minFrequency = mf;
|
Chris@37
|
805
|
Chris@37
|
806 emit layerParametersChanged();
|
Chris@37
|
807 }
|
Chris@37
|
808
|
Chris@37
|
809 size_t
|
Chris@37
|
810 SpectrogramLayer::getMinFrequency() const
|
Chris@37
|
811 {
|
Chris@37
|
812 return m_minFrequency;
|
Chris@37
|
813 }
|
Chris@37
|
814
|
Chris@37
|
815 void
|
Chris@0
|
816 SpectrogramLayer::setMaxFrequency(size_t mf)
|
Chris@0
|
817 {
|
Chris@0
|
818 if (m_maxFrequency == mf) return;
|
Chris@0
|
819
|
Chris@248
|
820 // std::cerr << "SpectrogramLayer::setMaxFrequency: " << mf << std::endl;
|
Chris@187
|
821
|
Chris@478
|
822 invalidateImageCaches();
|
Chris@119
|
823 invalidateMagnitudes();
|
Chris@0
|
824
|
Chris@0
|
825 m_maxFrequency = mf;
|
Chris@0
|
826
|
Chris@9
|
827 emit layerParametersChanged();
|
Chris@0
|
828 }
|
Chris@0
|
829
|
Chris@0
|
830 size_t
|
Chris@0
|
831 SpectrogramLayer::getMaxFrequency() const
|
Chris@0
|
832 {
|
Chris@0
|
833 return m_maxFrequency;
|
Chris@0
|
834 }
|
Chris@0
|
835
|
Chris@0
|
836 void
|
Chris@9
|
837 SpectrogramLayer::setColourRotation(int r)
|
Chris@9
|
838 {
|
Chris@478
|
839 invalidateImageCaches();
|
Chris@9
|
840
|
Chris@9
|
841 if (r < 0) r = 0;
|
Chris@9
|
842 if (r > 256) r = 256;
|
Chris@9
|
843 int distance = r - m_colourRotation;
|
Chris@9
|
844
|
Chris@9
|
845 if (distance != 0) {
|
Chris@197
|
846 rotatePalette(-distance);
|
Chris@9
|
847 m_colourRotation = r;
|
Chris@9
|
848 }
|
Chris@9
|
849
|
Chris@9
|
850 emit layerParametersChanged();
|
Chris@9
|
851 }
|
Chris@9
|
852
|
Chris@9
|
853 void
|
Chris@0
|
854 SpectrogramLayer::setColourScale(ColourScale colourScale)
|
Chris@0
|
855 {
|
Chris@0
|
856 if (m_colourScale == colourScale) return;
|
Chris@0
|
857
|
Chris@478
|
858 invalidateImageCaches();
|
Chris@0
|
859
|
Chris@0
|
860 m_colourScale = colourScale;
|
Chris@0
|
861
|
Chris@9
|
862 emit layerParametersChanged();
|
Chris@0
|
863 }
|
Chris@0
|
864
|
Chris@0
|
865 SpectrogramLayer::ColourScale
|
Chris@0
|
866 SpectrogramLayer::getColourScale() const
|
Chris@0
|
867 {
|
Chris@0
|
868 return m_colourScale;
|
Chris@0
|
869 }
|
Chris@0
|
870
|
Chris@0
|
871 void
|
Chris@197
|
872 SpectrogramLayer::setColourMap(int map)
|
Chris@0
|
873 {
|
Chris@197
|
874 if (m_colourMap == map) return;
|
Chris@0
|
875
|
Chris@478
|
876 invalidateImageCaches();
|
Chris@0
|
877
|
Chris@197
|
878 m_colourMap = map;
|
Chris@197
|
879 initialisePalette();
|
Chris@9
|
880
|
Chris@0
|
881 emit layerParametersChanged();
|
Chris@0
|
882 }
|
Chris@0
|
883
|
Chris@196
|
884 int
|
Chris@197
|
885 SpectrogramLayer::getColourMap() const
|
Chris@0
|
886 {
|
Chris@197
|
887 return m_colourMap;
|
Chris@0
|
888 }
|
Chris@0
|
889
|
Chris@0
|
890 void
|
Chris@0
|
891 SpectrogramLayer::setFrequencyScale(FrequencyScale frequencyScale)
|
Chris@0
|
892 {
|
Chris@0
|
893 if (m_frequencyScale == frequencyScale) return;
|
Chris@0
|
894
|
Chris@478
|
895 invalidateImageCaches();
|
Chris@0
|
896 m_frequencyScale = frequencyScale;
|
Chris@9
|
897
|
Chris@9
|
898 emit layerParametersChanged();
|
Chris@0
|
899 }
|
Chris@0
|
900
|
Chris@0
|
901 SpectrogramLayer::FrequencyScale
|
Chris@0
|
902 SpectrogramLayer::getFrequencyScale() const
|
Chris@0
|
903 {
|
Chris@0
|
904 return m_frequencyScale;
|
Chris@0
|
905 }
|
Chris@0
|
906
|
Chris@0
|
907 void
|
Chris@37
|
908 SpectrogramLayer::setBinDisplay(BinDisplay binDisplay)
|
Chris@35
|
909 {
|
Chris@37
|
910 if (m_binDisplay == binDisplay) return;
|
Chris@35
|
911
|
Chris@478
|
912 invalidateImageCaches();
|
Chris@37
|
913 m_binDisplay = binDisplay;
|
Chris@35
|
914
|
Chris@35
|
915 emit layerParametersChanged();
|
Chris@35
|
916 }
|
Chris@35
|
917
|
Chris@37
|
918 SpectrogramLayer::BinDisplay
|
Chris@37
|
919 SpectrogramLayer::getBinDisplay() const
|
Chris@35
|
920 {
|
Chris@37
|
921 return m_binDisplay;
|
Chris@35
|
922 }
|
Chris@35
|
923
|
Chris@35
|
924 void
|
Chris@36
|
925 SpectrogramLayer::setNormalizeColumns(bool n)
|
Chris@36
|
926 {
|
Chris@36
|
927 if (m_normalizeColumns == n) return;
|
Chris@36
|
928
|
Chris@478
|
929 invalidateImageCaches();
|
Chris@119
|
930 invalidateMagnitudes();
|
Chris@36
|
931 m_normalizeColumns = n;
|
Chris@36
|
932
|
Chris@36
|
933 emit layerParametersChanged();
|
Chris@36
|
934 }
|
Chris@36
|
935
|
Chris@36
|
936 bool
|
Chris@36
|
937 SpectrogramLayer::getNormalizeColumns() const
|
Chris@36
|
938 {
|
Chris@36
|
939 return m_normalizeColumns;
|
Chris@36
|
940 }
|
Chris@36
|
941
|
Chris@36
|
942 void
|
Chris@120
|
943 SpectrogramLayer::setNormalizeVisibleArea(bool n)
|
Chris@120
|
944 {
|
Chris@327
|
945 std::cerr << "SpectrogramLayer::setNormalizeVisibleArea(" << n
|
Chris@327
|
946 << ") (from " << m_normalizeVisibleArea << ")" << std::endl;
|
Chris@327
|
947
|
Chris@120
|
948 if (m_normalizeVisibleArea == n) return;
|
Chris@120
|
949
|
Chris@478
|
950 invalidateImageCaches();
|
Chris@120
|
951 invalidateMagnitudes();
|
Chris@120
|
952 m_normalizeVisibleArea = n;
|
Chris@120
|
953
|
Chris@120
|
954 emit layerParametersChanged();
|
Chris@120
|
955 }
|
Chris@120
|
956
|
Chris@120
|
957 bool
|
Chris@120
|
958 SpectrogramLayer::getNormalizeVisibleArea() const
|
Chris@120
|
959 {
|
Chris@120
|
960 return m_normalizeVisibleArea;
|
Chris@120
|
961 }
|
Chris@120
|
962
|
Chris@120
|
963 void
|
Chris@47
|
964 SpectrogramLayer::setLayerDormant(const View *v, bool dormant)
|
Chris@29
|
965 {
|
Chris@33
|
966 if (dormant) {
|
Chris@33
|
967
|
Chris@331
|
968 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@331
|
969 std::cerr << "SpectrogramLayer::setLayerDormant(" << dormant << ")"
|
Chris@331
|
970 << std::endl;
|
Chris@331
|
971 #endif
|
Chris@331
|
972
|
Chris@131
|
973 if (isLayerDormant(v)) {
|
Chris@131
|
974 return;
|
Chris@131
|
975 }
|
Chris@131
|
976
|
Chris@131
|
977 Layer::setLayerDormant(v, true);
|
Chris@33
|
978
|
Chris@478
|
979 invalidateImageCaches();
|
Chris@478
|
980 m_imageCaches.erase(v);
|
Chris@114
|
981
|
Chris@130
|
982 if (m_fftModels.find(v) != m_fftModels.end()) {
|
Chris@193
|
983
|
Chris@193
|
984 if (m_sliceableModel == m_fftModels[v].first) {
|
Chris@193
|
985 bool replaced = false;
|
Chris@193
|
986 for (ViewFFTMap::iterator i = m_fftModels.begin();
|
Chris@193
|
987 i != m_fftModels.end(); ++i) {
|
Chris@193
|
988 if (i->second.first != m_sliceableModel) {
|
Chris@193
|
989 emit sliceableModelReplaced(m_sliceableModel, i->second.first);
|
Chris@193
|
990 replaced = true;
|
Chris@193
|
991 break;
|
Chris@193
|
992 }
|
Chris@193
|
993 }
|
Chris@193
|
994 if (!replaced) emit sliceableModelReplaced(m_sliceableModel, 0);
|
Chris@193
|
995 }
|
Chris@193
|
996
|
Chris@130
|
997 delete m_fftModels[v].first;
|
Chris@130
|
998 m_fftModels.erase(v);
|
Chris@484
|
999
|
Chris@484
|
1000 delete m_peakCaches[v];
|
Chris@484
|
1001 m_peakCaches.erase(v);
|
Chris@114
|
1002 }
|
Chris@33
|
1003
|
Chris@33
|
1004 } else {
|
Chris@33
|
1005
|
Chris@131
|
1006 Layer::setLayerDormant(v, false);
|
Chris@33
|
1007 }
|
Chris@29
|
1008 }
|
Chris@29
|
1009
|
Chris@29
|
1010 void
|
Chris@0
|
1011 SpectrogramLayer::cacheInvalid()
|
Chris@0
|
1012 {
|
Chris@391
|
1013 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@391
|
1014 std::cerr << "SpectrogramLayer::cacheInvalid()" << std::endl;
|
Chris@391
|
1015 #endif
|
Chris@391
|
1016
|
Chris@478
|
1017 invalidateImageCaches();
|
Chris@119
|
1018 invalidateMagnitudes();
|
Chris@0
|
1019 }
|
Chris@0
|
1020
|
Chris@0
|
1021 void
|
Chris@391
|
1022 SpectrogramLayer::cacheInvalid(size_t from, size_t to)
|
Chris@0
|
1023 {
|
Chris@391
|
1024 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@391
|
1025 std::cerr << "SpectrogramLayer::cacheInvalid(" << from << ", " << to << ")" << std::endl;
|
Chris@391
|
1026 #endif
|
Chris@391
|
1027
|
Chris@478
|
1028 invalidateImageCaches(from, to);
|
Chris@391
|
1029 invalidateMagnitudes();
|
Chris@0
|
1030 }
|
Chris@0
|
1031
|
Chris@0
|
1032 void
|
Chris@0
|
1033 SpectrogramLayer::fillTimerTimedOut()
|
Chris@0
|
1034 {
|
Chris@115
|
1035 if (!m_model) return;
|
Chris@115
|
1036
|
Chris@115
|
1037 bool allDone = true;
|
Chris@115
|
1038
|
Chris@184
|
1039 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@184
|
1040 std::cerr << "SpectrogramLayer::fillTimerTimedOut: have " << m_fftModels.size() << " FFT models associated with views" << std::endl;
|
Chris@184
|
1041 #endif
|
Chris@184
|
1042
|
Chris@130
|
1043 for (ViewFFTMap::iterator i = m_fftModels.begin();
|
Chris@130
|
1044 i != m_fftModels.end(); ++i) {
|
Chris@115
|
1045
|
Chris@130
|
1046 const FFTModel *model = i->second.first;
|
Chris@115
|
1047 size_t lastFill = i->second.second;
|
Chris@115
|
1048
|
Chris@130
|
1049 if (model) {
|
Chris@130
|
1050
|
Chris@130
|
1051 size_t fill = model->getFillExtent();
|
Chris@115
|
1052
|
Chris@0
|
1053 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@130
|
1054 std::cerr << "SpectrogramLayer::fillTimerTimedOut: extent for " << model << ": " << fill << ", last " << lastFill << ", total " << m_model->getEndFrame() << std::endl;
|
Chris@0
|
1055 #endif
|
Chris@115
|
1056
|
Chris@115
|
1057 if (fill >= lastFill) {
|
Chris@115
|
1058 if (fill >= m_model->getEndFrame() && lastFill > 0) {
|
Chris@0
|
1059 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@115
|
1060 std::cerr << "complete!" << std::endl;
|
Chris@0
|
1061 #endif
|
Chris@478
|
1062 invalidateImageCaches();
|
Chris@184
|
1063 i->second.second = -1;
|
Chris@115
|
1064 emit modelChanged();
|
Chris@115
|
1065
|
Chris@115
|
1066 } else if (fill > lastFill) {
|
Chris@0
|
1067 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@115
|
1068 std::cerr << "SpectrogramLayer: emitting modelChanged("
|
Chris@115
|
1069 << lastFill << "," << fill << ")" << std::endl;
|
Chris@0
|
1070 #endif
|
Chris@478
|
1071 invalidateImageCaches(lastFill, fill);
|
Chris@184
|
1072 i->second.second = fill;
|
Chris@115
|
1073 emit modelChanged(lastFill, fill);
|
Chris@115
|
1074 }
|
Chris@115
|
1075 } else {
|
Chris@0
|
1076 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@115
|
1077 std::cerr << "SpectrogramLayer: going backwards, emitting modelChanged("
|
Chris@115
|
1078 << m_model->getStartFrame() << "," << m_model->getEndFrame() << ")" << std::endl;
|
Chris@0
|
1079 #endif
|
Chris@478
|
1080 invalidateImageCaches();
|
Chris@184
|
1081 i->second.second = fill;
|
Chris@115
|
1082 emit modelChanged(m_model->getStartFrame(), m_model->getEndFrame());
|
Chris@115
|
1083 }
|
Chris@115
|
1084
|
Chris@115
|
1085 if (i->second.second >= 0) {
|
Chris@115
|
1086 allDone = false;
|
Chris@115
|
1087 }
|
Chris@115
|
1088 }
|
Chris@0
|
1089 }
|
Chris@115
|
1090
|
Chris@115
|
1091 if (allDone) {
|
Chris@115
|
1092 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@115
|
1093 std::cerr << "SpectrogramLayer: all complete!" << std::endl;
|
Chris@115
|
1094 #endif
|
Chris@115
|
1095 delete m_updateTimer;
|
Chris@115
|
1096 m_updateTimer = 0;
|
Chris@115
|
1097 }
|
Chris@0
|
1098 }
|
Chris@0
|
1099
|
Chris@224
|
1100 bool
|
Chris@224
|
1101 SpectrogramLayer::hasLightBackground() const
|
Chris@224
|
1102 {
|
Chris@287
|
1103 return ColourMapper(m_colourMap, 1.f, 255.f).hasLightBackground();
|
Chris@224
|
1104 }
|
Chris@224
|
1105
|
Chris@0
|
1106 void
|
Chris@197
|
1107 SpectrogramLayer::initialisePalette()
|
Chris@0
|
1108 {
|
Chris@10
|
1109 int formerRotation = m_colourRotation;
|
Chris@10
|
1110
|
Chris@197
|
1111 if (m_colourMap == (int)ColourMapper::BlackOnWhite) {
|
Chris@197
|
1112 m_palette.setColour(NO_VALUE, Qt::white);
|
Chris@38
|
1113 } else {
|
Chris@197
|
1114 m_palette.setColour(NO_VALUE, Qt::black);
|
Chris@38
|
1115 }
|
Chris@0
|
1116
|
Chris@197
|
1117 ColourMapper mapper(m_colourMap, 1.f, 255.f);
|
Chris@196
|
1118
|
Chris@0
|
1119 for (int pixel = 1; pixel < 256; ++pixel) {
|
Chris@197
|
1120 m_palette.setColour(pixel, mapper.map(pixel));
|
Chris@0
|
1121 }
|
Chris@9
|
1122
|
Chris@196
|
1123 m_crosshairColour = mapper.getContrastingColour();
|
Chris@196
|
1124
|
Chris@9
|
1125 m_colourRotation = 0;
|
Chris@197
|
1126 rotatePalette(m_colourRotation - formerRotation);
|
Chris@10
|
1127 m_colourRotation = formerRotation;
|
Chris@478
|
1128
|
Chris@478
|
1129 m_drawBuffer = QImage();
|
Chris@9
|
1130 }
|
Chris@9
|
1131
|
Chris@9
|
1132 void
|
Chris@197
|
1133 SpectrogramLayer::rotatePalette(int distance)
|
Chris@9
|
1134 {
|
Chris@31
|
1135 QColor newPixels[256];
|
Chris@9
|
1136
|
Chris@197
|
1137 newPixels[NO_VALUE] = m_palette.getColour(NO_VALUE);
|
Chris@9
|
1138
|
Chris@9
|
1139 for (int pixel = 1; pixel < 256; ++pixel) {
|
Chris@9
|
1140 int target = pixel + distance;
|
Chris@9
|
1141 while (target < 1) target += 255;
|
Chris@9
|
1142 while (target > 255) target -= 255;
|
Chris@197
|
1143 newPixels[target] = m_palette.getColour(pixel);
|
Chris@9
|
1144 }
|
Chris@9
|
1145
|
Chris@9
|
1146 for (int pixel = 0; pixel < 256; ++pixel) {
|
Chris@197
|
1147 m_palette.setColour(pixel, newPixels[pixel]);
|
Chris@9
|
1148 }
|
Chris@478
|
1149
|
Chris@478
|
1150 m_drawBuffer = QImage();
|
Chris@0
|
1151 }
|
Chris@0
|
1152
|
Chris@38
|
1153 unsigned char
|
Chris@119
|
1154 SpectrogramLayer::getDisplayValue(View *v, float input) const
|
Chris@38
|
1155 {
|
Chris@38
|
1156 int value;
|
Chris@37
|
1157
|
Chris@120
|
1158 float min = 0.f;
|
Chris@120
|
1159 float max = 1.f;
|
Chris@120
|
1160
|
Chris@120
|
1161 if (m_normalizeVisibleArea) {
|
Chris@120
|
1162 min = m_viewMags[v].getMin();
|
Chris@120
|
1163 max = m_viewMags[v].getMax();
|
Chris@120
|
1164 } else if (!m_normalizeColumns) {
|
Chris@224
|
1165 if (m_colourScale == LinearColourScale //||
|
Chris@224
|
1166 // m_colourScale == MeterColourScale) {
|
Chris@224
|
1167 ) {
|
Chris@224
|
1168 max = 0.1f;
|
Chris@120
|
1169 }
|
Chris@120
|
1170 }
|
Chris@120
|
1171
|
Chris@119
|
1172 float thresh = -80.f;
|
Chris@119
|
1173
|
Chris@119
|
1174 if (max == 0.f) max = 1.f;
|
Chris@119
|
1175 if (max == min) min = max - 0.0001f;
|
Chris@119
|
1176
|
Chris@40
|
1177 switch (m_colourScale) {
|
Chris@40
|
1178
|
Chris@40
|
1179 default:
|
Chris@40
|
1180 case LinearColourScale:
|
Chris@119
|
1181 value = int(((input - min) / (max - min)) * 255.f) + 1;
|
Chris@40
|
1182 break;
|
Chris@40
|
1183
|
Chris@40
|
1184 case MeterColourScale:
|
Chris@210
|
1185 value = AudioLevel::multiplier_to_preview
|
Chris@210
|
1186 ((input - min) / (max - min), 254) + 1;
|
Chris@40
|
1187 break;
|
Chris@119
|
1188
|
Chris@210
|
1189 case dBSquaredColourScale:
|
Chris@215
|
1190 input = ((input - min) * (input - min)) / ((max - min) * (max - min));
|
Chris@133
|
1191 if (input > 0.f) {
|
Chris@133
|
1192 input = 10.f * log10f(input);
|
Chris@133
|
1193 } else {
|
Chris@133
|
1194 input = thresh;
|
Chris@133
|
1195 }
|
Chris@119
|
1196 if (min > 0.f) {
|
Chris@119
|
1197 thresh = 10.f * log10f(min * min);
|
Chris@119
|
1198 if (thresh < -80.f) thresh = -80.f;
|
Chris@119
|
1199 }
|
Chris@119
|
1200 input = (input - thresh) / (-thresh);
|
Chris@119
|
1201 if (input < 0.f) input = 0.f;
|
Chris@119
|
1202 if (input > 1.f) input = 1.f;
|
Chris@119
|
1203 value = int(input * 255.f) + 1;
|
Chris@119
|
1204 break;
|
Chris@40
|
1205
|
Chris@215
|
1206 case dBColourScale:
|
Chris@215
|
1207 //!!! experiment with normalizing the visible area this way.
|
Chris@215
|
1208 //In any case, we need to have some indication of what the dB
|
Chris@215
|
1209 //scale is relative to.
|
Chris@215
|
1210 input = (input - min) / (max - min);
|
Chris@215
|
1211 if (input > 0.f) {
|
Chris@215
|
1212 input = 10.f * log10f(input);
|
Chris@215
|
1213 } else {
|
Chris@215
|
1214 input = thresh;
|
Chris@215
|
1215 }
|
Chris@215
|
1216 if (min > 0.f) {
|
Chris@215
|
1217 thresh = 10.f * log10f(min);
|
Chris@215
|
1218 if (thresh < -80.f) thresh = -80.f;
|
Chris@215
|
1219 }
|
Chris@215
|
1220 input = (input - thresh) / (-thresh);
|
Chris@215
|
1221 if (input < 0.f) input = 0.f;
|
Chris@215
|
1222 if (input > 1.f) input = 1.f;
|
Chris@215
|
1223 value = int(input * 255.f) + 1;
|
Chris@215
|
1224 break;
|
Chris@215
|
1225
|
Chris@40
|
1226 case PhaseColourScale:
|
Chris@40
|
1227 value = int((input * 127.0 / M_PI) + 128);
|
Chris@40
|
1228 break;
|
Chris@0
|
1229 }
|
Chris@210
|
1230
|
Chris@38
|
1231 if (value > UCHAR_MAX) value = UCHAR_MAX;
|
Chris@38
|
1232 if (value < 0) value = 0;
|
Chris@38
|
1233 return value;
|
Chris@0
|
1234 }
|
Chris@0
|
1235
|
Chris@40
|
1236 float
|
Chris@40
|
1237 SpectrogramLayer::getInputForDisplayValue(unsigned char uc) const
|
Chris@40
|
1238 {
|
Chris@153
|
1239 //!!! unused
|
Chris@153
|
1240
|
Chris@40
|
1241 int value = uc;
|
Chris@40
|
1242 float input;
|
Chris@40
|
1243
|
Chris@120
|
1244 //!!! incorrect for normalizing visible area (and also out of date)
|
Chris@120
|
1245
|
Chris@40
|
1246 switch (m_colourScale) {
|
Chris@40
|
1247
|
Chris@40
|
1248 default:
|
Chris@40
|
1249 case LinearColourScale:
|
Chris@40
|
1250 input = float(value - 1) / 255.0 / (m_normalizeColumns ? 1 : 50);
|
Chris@40
|
1251 break;
|
Chris@40
|
1252
|
Chris@40
|
1253 case MeterColourScale:
|
Chris@40
|
1254 input = AudioLevel::preview_to_multiplier(value - 1, 255)
|
Chris@40
|
1255 / (m_normalizeColumns ? 1.0 : 50.0);
|
Chris@40
|
1256 break;
|
Chris@40
|
1257
|
Chris@215
|
1258 case dBSquaredColourScale:
|
Chris@40
|
1259 input = float(value - 1) / 255.0;
|
Chris@40
|
1260 input = (input * 80.0) - 80.0;
|
Chris@40
|
1261 input = powf(10.0, input) / 20.0;
|
Chris@40
|
1262 value = int(input);
|
Chris@40
|
1263 break;
|
Chris@40
|
1264
|
Chris@215
|
1265 case dBColourScale:
|
Chris@119
|
1266 input = float(value - 1) / 255.0;
|
Chris@119
|
1267 input = (input * 80.0) - 80.0;
|
Chris@119
|
1268 input = powf(10.0, input) / 20.0;
|
Chris@119
|
1269 value = int(input);
|
Chris@119
|
1270 break;
|
Chris@119
|
1271
|
Chris@40
|
1272 case PhaseColourScale:
|
Chris@40
|
1273 input = float(value - 128) * M_PI / 127.0;
|
Chris@40
|
1274 break;
|
Chris@40
|
1275 }
|
Chris@40
|
1276
|
Chris@40
|
1277 return input;
|
Chris@40
|
1278 }
|
Chris@40
|
1279
|
Chris@40
|
1280 float
|
Chris@40
|
1281 SpectrogramLayer::getEffectiveMinFrequency() const
|
Chris@40
|
1282 {
|
Chris@40
|
1283 int sr = m_model->getSampleRate();
|
Chris@107
|
1284 float minf = float(sr) / m_fftSize;
|
Chris@40
|
1285
|
Chris@40
|
1286 if (m_minFrequency > 0.0) {
|
Chris@107
|
1287 size_t minbin = size_t((double(m_minFrequency) * m_fftSize) / sr + 0.01);
|
Chris@40
|
1288 if (minbin < 1) minbin = 1;
|
Chris@107
|
1289 minf = minbin * sr / m_fftSize;
|
Chris@40
|
1290 }
|
Chris@40
|
1291
|
Chris@40
|
1292 return minf;
|
Chris@40
|
1293 }
|
Chris@40
|
1294
|
Chris@40
|
1295 float
|
Chris@40
|
1296 SpectrogramLayer::getEffectiveMaxFrequency() const
|
Chris@40
|
1297 {
|
Chris@40
|
1298 int sr = m_model->getSampleRate();
|
Chris@40
|
1299 float maxf = float(sr) / 2;
|
Chris@40
|
1300
|
Chris@40
|
1301 if (m_maxFrequency > 0.0) {
|
Chris@107
|
1302 size_t maxbin = size_t((double(m_maxFrequency) * m_fftSize) / sr + 0.1);
|
Chris@107
|
1303 if (maxbin > m_fftSize / 2) maxbin = m_fftSize / 2;
|
Chris@107
|
1304 maxf = maxbin * sr / m_fftSize;
|
Chris@40
|
1305 }
|
Chris@40
|
1306
|
Chris@40
|
1307 return maxf;
|
Chris@40
|
1308 }
|
Chris@40
|
1309
|
Chris@0
|
1310 bool
|
Chris@44
|
1311 SpectrogramLayer::getYBinRange(View *v, int y, float &q0, float &q1) const
|
Chris@0
|
1312 {
|
Chris@382
|
1313 Profiler profiler("SpectrogramLayer::getYBinRange");
|
Chris@382
|
1314
|
Chris@44
|
1315 int h = v->height();
|
Chris@0
|
1316 if (y < 0 || y >= h) return false;
|
Chris@0
|
1317
|
Chris@38
|
1318 int sr = m_model->getSampleRate();
|
Chris@40
|
1319 float minf = getEffectiveMinFrequency();
|
Chris@40
|
1320 float maxf = getEffectiveMaxFrequency();
|
Chris@0
|
1321
|
Chris@38
|
1322 bool logarithmic = (m_frequencyScale == LogFrequencyScale);
|
Chris@38
|
1323
|
Chris@44
|
1324 q0 = v->getFrequencyForY(y, minf, maxf, logarithmic);
|
Chris@44
|
1325 q1 = v->getFrequencyForY(y - 1, minf, maxf, logarithmic);
|
Chris@38
|
1326
|
Chris@486
|
1327 // Now map these on to actual bins, using raw FFT size (unsmoothed)
|
Chris@38
|
1328
|
Chris@107
|
1329 int b0 = int((q0 * m_fftSize) / sr);
|
Chris@107
|
1330 int b1 = int((q1 * m_fftSize) / sr);
|
Chris@0
|
1331
|
Chris@40
|
1332 //!!! this is supposed to return fractions-of-bins, as it were, hence the floats
|
Chris@38
|
1333 q0 = b0;
|
Chris@38
|
1334 q1 = b1;
|
Chris@38
|
1335
|
Chris@107
|
1336 // q0 = (b0 * sr) / m_fftSize;
|
Chris@107
|
1337 // q1 = (b1 * sr) / m_fftSize;
|
Chris@0
|
1338
|
Chris@0
|
1339 return true;
|
Chris@0
|
1340 }
|
Chris@486
|
1341
|
Chris@486
|
1342 bool
|
Chris@486
|
1343 SpectrogramLayer::getSmoothedYBinRange(View *v, int y, float &q0, float &q1) const
|
Chris@486
|
1344 {
|
Chris@486
|
1345 Profiler profiler("SpectrogramLayer::getSmoothedYBinRange");
|
Chris@486
|
1346
|
Chris@486
|
1347 int h = v->height();
|
Chris@486
|
1348 if (y < 0 || y >= h) return false;
|
Chris@486
|
1349
|
Chris@486
|
1350 int sr = m_model->getSampleRate();
|
Chris@486
|
1351 float minf = getEffectiveMinFrequency();
|
Chris@486
|
1352 float maxf = getEffectiveMaxFrequency();
|
Chris@486
|
1353
|
Chris@486
|
1354 bool logarithmic = (m_frequencyScale == LogFrequencyScale);
|
Chris@486
|
1355
|
Chris@486
|
1356 q0 = v->getFrequencyForY(y, minf, maxf, logarithmic);
|
Chris@486
|
1357 q1 = v->getFrequencyForY(y - 1, minf, maxf, logarithmic);
|
Chris@486
|
1358
|
Chris@486
|
1359 // Now map these on to actual bins, using zero-padded FFT size if
|
Chris@486
|
1360 // appropriate
|
Chris@486
|
1361
|
Chris@486
|
1362 int b0 = int((q0 * getFFTSize(v)) / sr);
|
Chris@486
|
1363 int b1 = int((q1 * getFFTSize(v)) / sr);
|
Chris@486
|
1364
|
Chris@486
|
1365 //!!! this is supposed to return fractions-of-bins, as it were, hence the floats
|
Chris@486
|
1366 q0 = b0;
|
Chris@486
|
1367 q1 = b1;
|
Chris@486
|
1368
|
Chris@486
|
1369 // q0 = (b0 * sr) / m_fftSize;
|
Chris@486
|
1370 // q1 = (b1 * sr) / m_fftSize;
|
Chris@486
|
1371
|
Chris@486
|
1372 return true;
|
Chris@486
|
1373 }
|
Chris@38
|
1374
|
Chris@0
|
1375 bool
|
Chris@44
|
1376 SpectrogramLayer::getXBinRange(View *v, int x, float &s0, float &s1) const
|
Chris@0
|
1377 {
|
Chris@21
|
1378 size_t modelStart = m_model->getStartFrame();
|
Chris@21
|
1379 size_t modelEnd = m_model->getEndFrame();
|
Chris@0
|
1380
|
Chris@0
|
1381 // Each pixel column covers an exact range of sample frames:
|
Chris@44
|
1382 int f0 = v->getFrameForX(x) - modelStart;
|
Chris@44
|
1383 int f1 = v->getFrameForX(x + 1) - modelStart - 1;
|
Chris@20
|
1384
|
Chris@41
|
1385 if (f1 < int(modelStart) || f0 > int(modelEnd)) {
|
Chris@41
|
1386 return false;
|
Chris@41
|
1387 }
|
Chris@20
|
1388
|
Chris@0
|
1389 // And that range may be drawn from a possibly non-integral
|
Chris@0
|
1390 // range of spectrogram windows:
|
Chris@0
|
1391
|
Chris@0
|
1392 size_t windowIncrement = getWindowIncrement();
|
Chris@0
|
1393 s0 = float(f0) / windowIncrement;
|
Chris@0
|
1394 s1 = float(f1) / windowIncrement;
|
Chris@0
|
1395
|
Chris@0
|
1396 return true;
|
Chris@0
|
1397 }
|
Chris@0
|
1398
|
Chris@0
|
1399 bool
|
Chris@44
|
1400 SpectrogramLayer::getXBinSourceRange(View *v, int x, RealTime &min, RealTime &max) const
|
Chris@0
|
1401 {
|
Chris@0
|
1402 float s0 = 0, s1 = 0;
|
Chris@44
|
1403 if (!getXBinRange(v, x, s0, s1)) return false;
|
Chris@0
|
1404
|
Chris@0
|
1405 int s0i = int(s0 + 0.001);
|
Chris@0
|
1406 int s1i = int(s1);
|
Chris@0
|
1407
|
Chris@0
|
1408 int windowIncrement = getWindowIncrement();
|
Chris@0
|
1409 int w0 = s0i * windowIncrement - (m_windowSize - windowIncrement)/2;
|
Chris@0
|
1410 int w1 = s1i * windowIncrement + windowIncrement +
|
Chris@0
|
1411 (m_windowSize - windowIncrement)/2 - 1;
|
Chris@0
|
1412
|
Chris@0
|
1413 min = RealTime::frame2RealTime(w0, m_model->getSampleRate());
|
Chris@0
|
1414 max = RealTime::frame2RealTime(w1, m_model->getSampleRate());
|
Chris@0
|
1415 return true;
|
Chris@0
|
1416 }
|
Chris@0
|
1417
|
Chris@0
|
1418 bool
|
Chris@44
|
1419 SpectrogramLayer::getYBinSourceRange(View *v, int y, float &freqMin, float &freqMax)
|
Chris@0
|
1420 const
|
Chris@0
|
1421 {
|
Chris@0
|
1422 float q0 = 0, q1 = 0;
|
Chris@44
|
1423 if (!getYBinRange(v, y, q0, q1)) return false;
|
Chris@0
|
1424
|
Chris@0
|
1425 int q0i = int(q0 + 0.001);
|
Chris@0
|
1426 int q1i = int(q1);
|
Chris@0
|
1427
|
Chris@0
|
1428 int sr = m_model->getSampleRate();
|
Chris@0
|
1429
|
Chris@0
|
1430 for (int q = q0i; q <= q1i; ++q) {
|
Chris@121
|
1431 if (q == q0i) freqMin = (sr * q) / m_fftSize;
|
Chris@121
|
1432 if (q == q1i) freqMax = (sr * (q+1)) / m_fftSize;
|
Chris@0
|
1433 }
|
Chris@0
|
1434 return true;
|
Chris@0
|
1435 }
|
Chris@35
|
1436
|
Chris@35
|
1437 bool
|
Chris@44
|
1438 SpectrogramLayer::getAdjustedYBinSourceRange(View *v, int x, int y,
|
Chris@35
|
1439 float &freqMin, float &freqMax,
|
Chris@35
|
1440 float &adjFreqMin, float &adjFreqMax)
|
Chris@35
|
1441 const
|
Chris@35
|
1442 {
|
Chris@277
|
1443 if (!m_model || !m_model->isOK() || !m_model->isReady()) {
|
Chris@277
|
1444 return false;
|
Chris@277
|
1445 }
|
Chris@277
|
1446
|
Chris@130
|
1447 FFTModel *fft = getFFTModel(v);
|
Chris@114
|
1448 if (!fft) return false;
|
Chris@110
|
1449
|
Chris@35
|
1450 float s0 = 0, s1 = 0;
|
Chris@44
|
1451 if (!getXBinRange(v, x, s0, s1)) return false;
|
Chris@35
|
1452
|
Chris@35
|
1453 float q0 = 0, q1 = 0;
|
Chris@44
|
1454 if (!getYBinRange(v, y, q0, q1)) return false;
|
Chris@35
|
1455
|
Chris@35
|
1456 int s0i = int(s0 + 0.001);
|
Chris@35
|
1457 int s1i = int(s1);
|
Chris@35
|
1458
|
Chris@35
|
1459 int q0i = int(q0 + 0.001);
|
Chris@35
|
1460 int q1i = int(q1);
|
Chris@35
|
1461
|
Chris@35
|
1462 int sr = m_model->getSampleRate();
|
Chris@35
|
1463
|
Chris@38
|
1464 size_t windowSize = m_windowSize;
|
Chris@38
|
1465 size_t windowIncrement = getWindowIncrement();
|
Chris@38
|
1466
|
Chris@35
|
1467 bool haveAdj = false;
|
Chris@35
|
1468
|
Chris@37
|
1469 bool peaksOnly = (m_binDisplay == PeakBins ||
|
Chris@37
|
1470 m_binDisplay == PeakFrequencies);
|
Chris@37
|
1471
|
Chris@35
|
1472 for (int q = q0i; q <= q1i; ++q) {
|
Chris@35
|
1473
|
Chris@35
|
1474 for (int s = s0i; s <= s1i; ++s) {
|
Chris@35
|
1475
|
Chris@160
|
1476 if (!fft->isColumnAvailable(s)) continue;
|
Chris@117
|
1477
|
Chris@35
|
1478 float binfreq = (sr * q) / m_windowSize;
|
Chris@35
|
1479 if (q == q0i) freqMin = binfreq;
|
Chris@35
|
1480 if (q == q1i) freqMax = binfreq;
|
Chris@37
|
1481
|
Chris@114
|
1482 if (peaksOnly && !fft->isLocalPeak(s, q)) continue;
|
Chris@38
|
1483
|
Chris@253
|
1484 if (!fft->isOverThreshold(s, q, m_threshold * (m_fftSize/2))) continue;
|
Chris@38
|
1485
|
Chris@38
|
1486 float freq = binfreq;
|
Chris@38
|
1487 bool steady = false;
|
Chris@40
|
1488
|
Chris@114
|
1489 if (s < int(fft->getWidth()) - 1) {
|
Chris@38
|
1490
|
Chris@277
|
1491 fft->estimateStableFrequency(s, q, freq);
|
Chris@35
|
1492
|
Chris@38
|
1493 if (!haveAdj || freq < adjFreqMin) adjFreqMin = freq;
|
Chris@38
|
1494 if (!haveAdj || freq > adjFreqMax) adjFreqMax = freq;
|
Chris@35
|
1495
|
Chris@35
|
1496 haveAdj = true;
|
Chris@35
|
1497 }
|
Chris@35
|
1498 }
|
Chris@35
|
1499 }
|
Chris@35
|
1500
|
Chris@35
|
1501 if (!haveAdj) {
|
Chris@40
|
1502 adjFreqMin = adjFreqMax = 0.0;
|
Chris@35
|
1503 }
|
Chris@35
|
1504
|
Chris@35
|
1505 return haveAdj;
|
Chris@35
|
1506 }
|
Chris@0
|
1507
|
Chris@0
|
1508 bool
|
Chris@44
|
1509 SpectrogramLayer::getXYBinSourceRange(View *v, int x, int y,
|
Chris@38
|
1510 float &min, float &max,
|
Chris@38
|
1511 float &phaseMin, float &phaseMax) const
|
Chris@0
|
1512 {
|
Chris@277
|
1513 if (!m_model || !m_model->isOK() || !m_model->isReady()) {
|
Chris@277
|
1514 return false;
|
Chris@277
|
1515 }
|
Chris@277
|
1516
|
Chris@0
|
1517 float q0 = 0, q1 = 0;
|
Chris@44
|
1518 if (!getYBinRange(v, y, q0, q1)) return false;
|
Chris@0
|
1519
|
Chris@0
|
1520 float s0 = 0, s1 = 0;
|
Chris@44
|
1521 if (!getXBinRange(v, x, s0, s1)) return false;
|
Chris@0
|
1522
|
Chris@0
|
1523 int q0i = int(q0 + 0.001);
|
Chris@0
|
1524 int q1i = int(q1);
|
Chris@0
|
1525
|
Chris@0
|
1526 int s0i = int(s0 + 0.001);
|
Chris@0
|
1527 int s1i = int(s1);
|
Chris@0
|
1528
|
Chris@37
|
1529 bool rv = false;
|
Chris@37
|
1530
|
Chris@122
|
1531 size_t zp = getZeroPadLevel(v);
|
Chris@122
|
1532 q0i *= zp + 1;
|
Chris@122
|
1533 q1i *= zp + 1;
|
Chris@122
|
1534
|
Chris@130
|
1535 FFTModel *fft = getFFTModel(v);
|
Chris@0
|
1536
|
Chris@114
|
1537 if (fft) {
|
Chris@114
|
1538
|
Chris@114
|
1539 int cw = fft->getWidth();
|
Chris@114
|
1540 int ch = fft->getHeight();
|
Chris@0
|
1541
|
Chris@110
|
1542 min = 0.0;
|
Chris@110
|
1543 max = 0.0;
|
Chris@110
|
1544 phaseMin = 0.0;
|
Chris@110
|
1545 phaseMax = 0.0;
|
Chris@110
|
1546 bool have = false;
|
Chris@0
|
1547
|
Chris@110
|
1548 for (int q = q0i; q <= q1i; ++q) {
|
Chris@110
|
1549 for (int s = s0i; s <= s1i; ++s) {
|
Chris@110
|
1550 if (s >= 0 && q >= 0 && s < cw && q < ch) {
|
Chris@117
|
1551
|
Chris@160
|
1552 if (!fft->isColumnAvailable(s)) continue;
|
Chris@110
|
1553
|
Chris@110
|
1554 float value;
|
Chris@38
|
1555
|
Chris@114
|
1556 value = fft->getPhaseAt(s, q);
|
Chris@110
|
1557 if (!have || value < phaseMin) { phaseMin = value; }
|
Chris@110
|
1558 if (!have || value > phaseMax) { phaseMax = value; }
|
Chris@91
|
1559
|
Chris@252
|
1560 value = fft->getMagnitudeAt(s, q) / (m_fftSize/2);
|
Chris@110
|
1561 if (!have || value < min) { min = value; }
|
Chris@110
|
1562 if (!have || value > max) { max = value; }
|
Chris@110
|
1563
|
Chris@110
|
1564 have = true;
|
Chris@110
|
1565 }
|
Chris@110
|
1566 }
|
Chris@110
|
1567 }
|
Chris@110
|
1568
|
Chris@110
|
1569 if (have) {
|
Chris@110
|
1570 rv = true;
|
Chris@110
|
1571 }
|
Chris@0
|
1572 }
|
Chris@0
|
1573
|
Chris@37
|
1574 return rv;
|
Chris@0
|
1575 }
|
Chris@0
|
1576
|
Chris@114
|
1577 size_t
|
Chris@114
|
1578 SpectrogramLayer::getZeroPadLevel(const View *v) const
|
Chris@114
|
1579 {
|
Chris@114
|
1580 //!!! tidy all this stuff
|
Chris@114
|
1581
|
Chris@114
|
1582 if (m_binDisplay != AllBins) return 0;
|
Chris@221
|
1583
|
Chris@221
|
1584 Preferences::SpectrogramSmoothing smoothing =
|
Chris@221
|
1585 Preferences::getInstance()->getSpectrogramSmoothing();
|
Chris@221
|
1586
|
Chris@221
|
1587 if (smoothing == Preferences::NoSpectrogramSmoothing ||
|
Chris@221
|
1588 smoothing == Preferences::SpectrogramInterpolated) return 0;
|
Chris@221
|
1589
|
Chris@114
|
1590 if (m_frequencyScale == LogFrequencyScale) return 3;
|
Chris@114
|
1591
|
Chris@114
|
1592 int sr = m_model->getSampleRate();
|
Chris@114
|
1593
|
Chris@184
|
1594 size_t maxbin = m_fftSize / 2;
|
Chris@114
|
1595 if (m_maxFrequency > 0) {
|
Chris@184
|
1596 maxbin = int((double(m_maxFrequency) * m_fftSize) / sr + 0.1);
|
Chris@184
|
1597 if (maxbin > m_fftSize / 2) maxbin = m_fftSize / 2;
|
Chris@114
|
1598 }
|
Chris@114
|
1599
|
Chris@114
|
1600 size_t minbin = 1;
|
Chris@114
|
1601 if (m_minFrequency > 0) {
|
Chris@114
|
1602 minbin = int((double(m_minFrequency) * m_fftSize) / sr + 0.1);
|
Chris@114
|
1603 if (minbin < 1) minbin = 1;
|
Chris@184
|
1604 if (minbin >= maxbin) minbin = maxbin - 1;
|
Chris@114
|
1605 }
|
Chris@114
|
1606
|
Chris@118
|
1607 float perPixel =
|
Chris@118
|
1608 float(v->height()) /
|
Chris@184
|
1609 float((maxbin - minbin) / (m_zeroPadLevel + 1));
|
Chris@118
|
1610
|
Chris@118
|
1611 if (perPixel > 2.8) {
|
Chris@118
|
1612 return 3; // 4x oversampling
|
Chris@118
|
1613 } else if (perPixel > 1.5) {
|
Chris@118
|
1614 return 1; // 2x
|
Chris@114
|
1615 } else {
|
Chris@118
|
1616 return 0; // 1x
|
Chris@114
|
1617 }
|
Chris@114
|
1618 }
|
Chris@114
|
1619
|
Chris@114
|
1620 size_t
|
Chris@114
|
1621 SpectrogramLayer::getFFTSize(const View *v) const
|
Chris@114
|
1622 {
|
Chris@114
|
1623 return m_fftSize * (getZeroPadLevel(v) + 1);
|
Chris@114
|
1624 }
|
Chris@114
|
1625
|
Chris@130
|
1626 FFTModel *
|
Chris@130
|
1627 SpectrogramLayer::getFFTModel(const View *v) const
|
Chris@114
|
1628 {
|
Chris@114
|
1629 if (!m_model) return 0;
|
Chris@114
|
1630
|
Chris@114
|
1631 size_t fftSize = getFFTSize(v);
|
Chris@114
|
1632
|
Chris@130
|
1633 if (m_fftModels.find(v) != m_fftModels.end()) {
|
Chris@184
|
1634 if (m_fftModels[v].first == 0) {
|
Chris@184
|
1635 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@184
|
1636 std::cerr << "SpectrogramLayer::getFFTModel(" << v << "): Found null model" << std::endl;
|
Chris@184
|
1637 #endif
|
Chris@184
|
1638 return 0;
|
Chris@184
|
1639 }
|
Chris@184
|
1640 if (m_fftModels[v].first->getHeight() != fftSize / 2 + 1) {
|
Chris@184
|
1641 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@184
|
1642 std::cerr << "SpectrogramLayer::getFFTModel(" << v << "): Found a model with the wrong height (" << m_fftModels[v].first->getHeight() << ", wanted " << (fftSize / 2 + 1) << ")" << std::endl;
|
Chris@184
|
1643 #endif
|
Chris@130
|
1644 delete m_fftModels[v].first;
|
Chris@130
|
1645 m_fftModels.erase(v);
|
Chris@484
|
1646 delete m_peakCaches[v];
|
Chris@484
|
1647 m_peakCaches.erase(v);
|
Chris@184
|
1648 } else {
|
Chris@184
|
1649 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@187
|
1650 std::cerr << "SpectrogramLayer::getFFTModel(" << v << "): Found a good model of height " << m_fftModels[v].first->getHeight() << std::endl;
|
Chris@184
|
1651 #endif
|
Chris@184
|
1652 return m_fftModels[v].first;
|
Chris@114
|
1653 }
|
Chris@114
|
1654 }
|
Chris@114
|
1655
|
Chris@130
|
1656 if (m_fftModels.find(v) == m_fftModels.end()) {
|
Chris@169
|
1657
|
Chris@169
|
1658 FFTModel *model = new FFTModel(m_model,
|
Chris@169
|
1659 m_channel,
|
Chris@169
|
1660 m_windowType,
|
Chris@169
|
1661 m_windowSize,
|
Chris@169
|
1662 getWindowIncrement(),
|
Chris@169
|
1663 fftSize,
|
Chris@382
|
1664 true, // polar
|
Chris@327
|
1665 StorageAdviser::SpeedCritical,
|
Chris@169
|
1666 m_candidateFillStartFrame);
|
Chris@169
|
1667
|
Chris@178
|
1668 if (!model->isOK()) {
|
Chris@178
|
1669 QMessageBox::critical
|
Chris@178
|
1670 (0, tr("FFT cache failed"),
|
Chris@178
|
1671 tr("Failed to create the FFT model for this spectrogram.\n"
|
Chris@178
|
1672 "There may be insufficient memory or disc space to continue."));
|
Chris@178
|
1673 delete model;
|
Chris@178
|
1674 m_fftModels[v] = FFTFillPair(0, 0);
|
Chris@178
|
1675 return 0;
|
Chris@178
|
1676 }
|
Chris@178
|
1677
|
Chris@193
|
1678 if (!m_sliceableModel) {
|
Chris@248
|
1679 #ifdef DEBUG_SPECTROGRAM
|
Chris@193
|
1680 std::cerr << "SpectrogramLayer: emitting sliceableModelReplaced(0, " << model << ")" << std::endl;
|
Chris@248
|
1681 #endif
|
Chris@193
|
1682 ((SpectrogramLayer *)this)->sliceableModelReplaced(0, model);
|
Chris@193
|
1683 m_sliceableModel = model;
|
Chris@193
|
1684 }
|
Chris@193
|
1685
|
Chris@169
|
1686 m_fftModels[v] = FFTFillPair(model, 0);
|
Chris@169
|
1687
|
Chris@169
|
1688 model->resume();
|
Chris@114
|
1689
|
Chris@114
|
1690 delete m_updateTimer;
|
Chris@114
|
1691 m_updateTimer = new QTimer((SpectrogramLayer *)this);
|
Chris@114
|
1692 connect(m_updateTimer, SIGNAL(timeout()),
|
Chris@114
|
1693 this, SLOT(fillTimerTimedOut()));
|
Chris@114
|
1694 m_updateTimer->start(200);
|
Chris@114
|
1695 }
|
Chris@114
|
1696
|
Chris@130
|
1697 return m_fftModels[v].first;
|
Chris@114
|
1698 }
|
Chris@114
|
1699
|
Chris@484
|
1700 Dense3DModelPeakCache *
|
Chris@484
|
1701 SpectrogramLayer::getPeakCache(const View *v) const
|
Chris@484
|
1702 {
|
Chris@484
|
1703 if (!m_peakCaches[v]) {
|
Chris@484
|
1704 FFTModel *f = getFFTModel(v);
|
Chris@484
|
1705 if (!f) return 0;
|
Chris@484
|
1706 m_peakCaches[v] = new Dense3DModelPeakCache(f, 8);
|
Chris@484
|
1707 }
|
Chris@484
|
1708 return m_peakCaches[v];
|
Chris@484
|
1709 }
|
Chris@484
|
1710
|
Chris@193
|
1711 const Model *
|
Chris@193
|
1712 SpectrogramLayer::getSliceableModel() const
|
Chris@193
|
1713 {
|
Chris@193
|
1714 if (m_sliceableModel) return m_sliceableModel;
|
Chris@193
|
1715 if (m_fftModels.empty()) return 0;
|
Chris@193
|
1716 m_sliceableModel = m_fftModels.begin()->second.first;
|
Chris@193
|
1717 return m_sliceableModel;
|
Chris@193
|
1718 }
|
Chris@193
|
1719
|
Chris@114
|
1720 void
|
Chris@130
|
1721 SpectrogramLayer::invalidateFFTModels()
|
Chris@114
|
1722 {
|
Chris@130
|
1723 for (ViewFFTMap::iterator i = m_fftModels.begin();
|
Chris@130
|
1724 i != m_fftModels.end(); ++i) {
|
Chris@115
|
1725 delete i->second.first;
|
Chris@114
|
1726 }
|
Chris@486
|
1727 for (PeakCacheMap::iterator i = m_peakCaches.begin();
|
Chris@486
|
1728 i != m_peakCaches.end(); ++i) {
|
Chris@486
|
1729 delete i->second;
|
Chris@486
|
1730 }
|
Chris@114
|
1731
|
Chris@130
|
1732 m_fftModels.clear();
|
Chris@486
|
1733 m_peakCaches.clear();
|
Chris@193
|
1734
|
Chris@193
|
1735 if (m_sliceableModel) {
|
Chris@193
|
1736 std::cerr << "SpectrogramLayer: emitting sliceableModelReplaced(" << m_sliceableModel << ", 0)" << std::endl;
|
Chris@193
|
1737 emit sliceableModelReplaced(m_sliceableModel, 0);
|
Chris@193
|
1738 m_sliceableModel = 0;
|
Chris@193
|
1739 }
|
Chris@114
|
1740 }
|
Chris@114
|
1741
|
Chris@0
|
1742 void
|
Chris@119
|
1743 SpectrogramLayer::invalidateMagnitudes()
|
Chris@119
|
1744 {
|
Chris@119
|
1745 m_viewMags.clear();
|
Chris@119
|
1746 for (std::vector<MagnitudeRange>::iterator i = m_columnMags.begin();
|
Chris@119
|
1747 i != m_columnMags.end(); ++i) {
|
Chris@119
|
1748 *i = MagnitudeRange();
|
Chris@119
|
1749 }
|
Chris@119
|
1750 }
|
Chris@119
|
1751
|
Chris@119
|
1752 bool
|
Chris@119
|
1753 SpectrogramLayer::updateViewMagnitudes(View *v) const
|
Chris@119
|
1754 {
|
Chris@119
|
1755 MagnitudeRange mag;
|
Chris@119
|
1756
|
Chris@119
|
1757 int x0 = 0, x1 = v->width();
|
Chris@119
|
1758 float s00 = 0, s01 = 0, s10 = 0, s11 = 0;
|
Chris@119
|
1759
|
Chris@203
|
1760 if (!getXBinRange(v, x0, s00, s01)) {
|
Chris@203
|
1761 s00 = s01 = m_model->getStartFrame() / getWindowIncrement();
|
Chris@203
|
1762 }
|
Chris@203
|
1763
|
Chris@203
|
1764 if (!getXBinRange(v, x1, s10, s11)) {
|
Chris@203
|
1765 s10 = s11 = m_model->getEndFrame() / getWindowIncrement();
|
Chris@203
|
1766 }
|
Chris@119
|
1767
|
Chris@119
|
1768 int s0 = int(std::min(s00, s10) + 0.0001);
|
Chris@203
|
1769 int s1 = int(std::max(s01, s11) + 0.0001);
|
Chris@203
|
1770
|
Chris@203
|
1771 // std::cerr << "SpectrogramLayer::updateViewMagnitudes: x0 = " << x0 << ", x1 = " << x1 << ", s00 = " << s00 << ", s11 = " << s11 << " s0 = " << s0 << ", s1 = " << s1 << std::endl;
|
Chris@119
|
1772
|
Chris@248
|
1773 if (int(m_columnMags.size()) <= s1) {
|
Chris@119
|
1774 m_columnMags.resize(s1 + 1);
|
Chris@119
|
1775 }
|
Chris@119
|
1776
|
Chris@119
|
1777 for (int s = s0; s <= s1; ++s) {
|
Chris@119
|
1778 if (m_columnMags[s].isSet()) {
|
Chris@119
|
1779 mag.sample(m_columnMags[s]);
|
Chris@119
|
1780 }
|
Chris@119
|
1781 }
|
Chris@119
|
1782
|
Chris@184
|
1783 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@119
|
1784 std::cerr << "SpectrogramLayer::updateViewMagnitudes returning from cols "
|
Chris@119
|
1785 << s0 << " -> " << s1 << " inclusive" << std::endl;
|
Chris@184
|
1786 #endif
|
Chris@119
|
1787
|
Chris@119
|
1788 if (!mag.isSet()) return false;
|
Chris@119
|
1789 if (mag == m_viewMags[v]) return false;
|
Chris@119
|
1790 m_viewMags[v] = mag;
|
Chris@119
|
1791 return true;
|
Chris@119
|
1792 }
|
Chris@119
|
1793
|
Chris@119
|
1794 void
|
Chris@389
|
1795 SpectrogramLayer::setSynchronousPainting(bool synchronous)
|
Chris@389
|
1796 {
|
Chris@389
|
1797 m_synchronous = synchronous;
|
Chris@389
|
1798 }
|
Chris@389
|
1799
|
Chris@389
|
1800 void
|
Chris@44
|
1801 SpectrogramLayer::paint(View *v, QPainter &paint, QRect rect) const
|
Chris@0
|
1802 {
|
Chris@253
|
1803 // What a lovely, old-fashioned function this is.
|
Chris@253
|
1804 // It's practically FORTRAN 77 in its clarity and linearity.
|
Chris@253
|
1805
|
Chris@334
|
1806 Profiler profiler("SpectrogramLayer::paint", false);
|
Chris@334
|
1807
|
Chris@0
|
1808 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@95
|
1809 std::cerr << "SpectrogramLayer::paint(): m_model is " << m_model << ", zoom level is " << v->getZoomLevel() << ", m_updateTimer " << m_updateTimer << std::endl;
|
Chris@95
|
1810
|
Chris@95
|
1811 std::cerr << "rect is " << rect.x() << "," << rect.y() << " " << rect.width() << "x" << rect.height() << std::endl;
|
Chris@0
|
1812 #endif
|
Chris@95
|
1813
|
Chris@133
|
1814 long startFrame = v->getStartFrame();
|
Chris@133
|
1815 if (startFrame < 0) m_candidateFillStartFrame = 0;
|
Chris@133
|
1816 else m_candidateFillStartFrame = startFrame;
|
Chris@44
|
1817
|
Chris@0
|
1818 if (!m_model || !m_model->isOK() || !m_model->isReady()) {
|
Chris@0
|
1819 return;
|
Chris@0
|
1820 }
|
Chris@0
|
1821
|
Chris@47
|
1822 if (isLayerDormant(v)) {
|
Chris@48
|
1823 std::cerr << "SpectrogramLayer::paint(): Layer is dormant, making it undormant again" << std::endl;
|
Chris@29
|
1824 }
|
Chris@29
|
1825
|
Chris@48
|
1826 // Need to do this even if !isLayerDormant, as that could mean v
|
Chris@48
|
1827 // is not in the dormancy map at all -- we need it to be present
|
Chris@48
|
1828 // and accountable for when determining whether we need the cache
|
Chris@48
|
1829 // in the cache-fill thread above.
|
Chris@131
|
1830 //!!! no longer use cache-fill thread
|
Chris@131
|
1831 const_cast<SpectrogramLayer *>(this)->Layer::setLayerDormant(v, false);
|
Chris@48
|
1832
|
Chris@114
|
1833 size_t fftSize = getFFTSize(v);
|
Chris@484
|
1834 /*
|
Chris@130
|
1835 FFTModel *fft = getFFTModel(v);
|
Chris@114
|
1836 if (!fft) {
|
Chris@130
|
1837 std::cerr << "ERROR: SpectrogramLayer::paint(): No FFT model, returning" << std::endl;
|
Chris@0
|
1838 return;
|
Chris@0
|
1839 }
|
Chris@484
|
1840 */
|
Chris@478
|
1841 ImageCache &cache = m_imageCaches[v];
|
Chris@95
|
1842
|
Chris@95
|
1843 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@478
|
1844 std::cerr << "SpectrogramLayer::paint(): image cache valid area " << cache.
|
Chris@477
|
1845
|
Chris@477
|
1846 validArea.x() << ", " << cache.validArea.y() << ", " << cache.validArea.width() << "x" << cache.validArea.height() << std::endl;
|
Chris@95
|
1847 #endif
|
Chris@95
|
1848
|
Chris@248
|
1849 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@0
|
1850 bool stillCacheing = (m_updateTimer != 0);
|
Chris@0
|
1851 std::cerr << "SpectrogramLayer::paint(): Still cacheing = " << stillCacheing << std::endl;
|
Chris@0
|
1852 #endif
|
Chris@0
|
1853
|
Chris@44
|
1854 int zoomLevel = v->getZoomLevel();
|
Chris@0
|
1855
|
Chris@0
|
1856 int x0 = 0;
|
Chris@44
|
1857 int x1 = v->width();
|
Chris@0
|
1858
|
Chris@478
|
1859 bool recreateWholeImageCache = true;
|
Chris@0
|
1860
|
Chris@95
|
1861 x0 = rect.left();
|
Chris@95
|
1862 x1 = rect.right() + 1;
|
Chris@481
|
1863 /*
|
Chris@479
|
1864 float xPixelRatio = float(fft->getResolution()) / float(zoomLevel);
|
Chris@479
|
1865 std::cerr << "xPixelRatio = " << xPixelRatio << std::endl;
|
Chris@479
|
1866 if (xPixelRatio < 1.f) xPixelRatio = 1.f;
|
Chris@481
|
1867 */
|
Chris@95
|
1868 if (cache.validArea.width() > 0) {
|
Chris@95
|
1869
|
Chris@482
|
1870 int cw = cache.image.width();
|
Chris@482
|
1871 int ch = cache.image.height();
|
Chris@482
|
1872
|
Chris@95
|
1873 if (int(cache.zoomLevel) == zoomLevel &&
|
Chris@482
|
1874 cw == v->width() &&
|
Chris@482
|
1875 ch == v->height()) {
|
Chris@95
|
1876
|
Chris@95
|
1877 if (v->getXForFrame(cache.startFrame) ==
|
Chris@95
|
1878 v->getXForFrame(startFrame) &&
|
Chris@95
|
1879 cache.validArea.x() <= x0 &&
|
Chris@95
|
1880 cache.validArea.x() + cache.validArea.width() >= x1) {
|
Chris@0
|
1881
|
Chris@0
|
1882 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@478
|
1883 std::cerr << "SpectrogramLayer: image cache good" << std::endl;
|
Chris@0
|
1884 #endif
|
Chris@0
|
1885
|
Chris@478
|
1886 paint.drawImage(rect, cache.image, rect);
|
Chris@479
|
1887 //!!!
|
Chris@479
|
1888 // paint.drawImage(v->rect(), cache.image,
|
Chris@479
|
1889 // QRect(QPoint(0, 0), cache.image.size()));
|
Chris@479
|
1890
|
Chris@121
|
1891 illuminateLocalFeatures(v, paint);
|
Chris@0
|
1892 return;
|
Chris@0
|
1893
|
Chris@0
|
1894 } else {
|
Chris@0
|
1895
|
Chris@0
|
1896 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@478
|
1897 std::cerr << "SpectrogramLayer: image cache partially OK" << std::endl;
|
Chris@0
|
1898 #endif
|
Chris@0
|
1899
|
Chris@478
|
1900 recreateWholeImageCache = false;
|
Chris@0
|
1901
|
Chris@95
|
1902 int dx = v->getXForFrame(cache.startFrame) -
|
Chris@44
|
1903 v->getXForFrame(startFrame);
|
Chris@0
|
1904
|
Chris@0
|
1905 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@482
|
1906 std::cerr << "SpectrogramLayer: dx = " << dx << " (image cache " << cw << "x" << ch << ")" << std::endl;
|
Chris@0
|
1907 #endif
|
Chris@0
|
1908
|
Chris@95
|
1909 if (dx != 0 &&
|
Chris@482
|
1910 dx > -cw &&
|
Chris@482
|
1911 dx < cw) {
|
Chris@482
|
1912
|
Chris@482
|
1913 int dxp = dx;
|
Chris@482
|
1914 if (dxp < 0) dxp = -dxp;
|
Chris@482
|
1915 int copy = (cw - dxp) * sizeof(QRgb);
|
Chris@482
|
1916 for (int y = 0; y < ch; ++y) {
|
Chris@482
|
1917 QRgb *line = (QRgb *)cache.image.scanLine(y);
|
Chris@482
|
1918 if (dx < 0) {
|
Chris@482
|
1919 memmove(line, line + dxp, copy);
|
Chris@482
|
1920 } else {
|
Chris@482
|
1921 memmove(line + dxp, line, copy);
|
Chris@482
|
1922 }
|
Chris@331
|
1923 }
|
Chris@0
|
1924
|
Chris@95
|
1925 int px = cache.validArea.x();
|
Chris@95
|
1926 int pw = cache.validArea.width();
|
Chris@0
|
1927
|
Chris@0
|
1928 if (dx < 0) {
|
Chris@482
|
1929 x0 = cw + dx;
|
Chris@482
|
1930 x1 = cw;
|
Chris@95
|
1931 px += dx;
|
Chris@95
|
1932 if (px < 0) {
|
Chris@95
|
1933 pw += px;
|
Chris@95
|
1934 px = 0;
|
Chris@95
|
1935 if (pw < 0) pw = 0;
|
Chris@95
|
1936 }
|
Chris@0
|
1937 } else {
|
Chris@0
|
1938 x0 = 0;
|
Chris@0
|
1939 x1 = dx;
|
Chris@95
|
1940 px += dx;
|
Chris@482
|
1941 if (px + pw > cw) {
|
Chris@482
|
1942 pw = int(cw) - px;
|
Chris@95
|
1943 if (pw < 0) pw = 0;
|
Chris@95
|
1944 }
|
Chris@0
|
1945 }
|
Chris@95
|
1946
|
Chris@95
|
1947 cache.validArea =
|
Chris@95
|
1948 QRect(px, cache.validArea.y(),
|
Chris@95
|
1949 pw, cache.validArea.height());
|
Chris@95
|
1950
|
Chris@331
|
1951 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@331
|
1952 std::cerr << "valid area now "
|
Chris@331
|
1953 << px << "," << cache.validArea.y()
|
Chris@331
|
1954 << " " << pw << "x" << cache.validArea.height()
|
Chris@331
|
1955 << std::endl;
|
Chris@331
|
1956 #endif
|
Chris@479
|
1957 /*
|
Chris@478
|
1958 paint.drawImage(rect & cache.validArea,
|
Chris@478
|
1959 cache.image,
|
Chris@95
|
1960 rect & cache.validArea);
|
Chris@479
|
1961 */
|
Chris@331
|
1962 } else if (dx != 0) {
|
Chris@331
|
1963
|
Chris@331
|
1964 // we scrolled too far to be of use
|
Chris@331
|
1965
|
Chris@391
|
1966 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@391
|
1967 std::cerr << "dx == " << dx << ": scrolled too far for cache to be useful" << std::endl;
|
Chris@391
|
1968 #endif
|
Chris@391
|
1969
|
Chris@331
|
1970 cache.validArea = QRect();
|
Chris@478
|
1971 recreateWholeImageCache = true;
|
Chris@331
|
1972 }
|
Chris@0
|
1973 }
|
Chris@0
|
1974 } else {
|
Chris@0
|
1975 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@478
|
1976 std::cerr << "SpectrogramLayer: image cache useless" << std::endl;
|
Chris@224
|
1977 if (int(cache.zoomLevel) != zoomLevel) {
|
Chris@224
|
1978 std::cerr << "(cache zoomLevel " << cache.zoomLevel
|
Chris@224
|
1979 << " != " << zoomLevel << ")" << std::endl;
|
Chris@224
|
1980 }
|
Chris@482
|
1981 if (cw != v->width()) {
|
Chris@482
|
1982 std::cerr << "(cache width " << cw
|
Chris@224
|
1983 << " != " << v->width();
|
Chris@224
|
1984 }
|
Chris@482
|
1985 if (ch != v->height()) {
|
Chris@482
|
1986 std::cerr << "(cache height " << ch
|
Chris@224
|
1987 << " != " << v->height();
|
Chris@224
|
1988 }
|
Chris@0
|
1989 #endif
|
Chris@95
|
1990 cache.validArea = QRect();
|
Chris@478
|
1991 // recreateWholeImageCache = true;
|
Chris@0
|
1992 }
|
Chris@0
|
1993 }
|
Chris@95
|
1994
|
Chris@133
|
1995 if (updateViewMagnitudes(v)) {
|
Chris@184
|
1996 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@133
|
1997 std::cerr << "SpectrogramLayer: magnitude range changed to [" << m_viewMags[v].getMin() << "->" << m_viewMags[v].getMax() << "]" << std::endl;
|
Chris@184
|
1998 #endif
|
Chris@331
|
1999 if (m_normalizeVisibleArea) {
|
Chris@331
|
2000 cache.validArea = QRect();
|
Chris@478
|
2001 recreateWholeImageCache = true;
|
Chris@331
|
2002 }
|
Chris@133
|
2003 } else {
|
Chris@184
|
2004 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@133
|
2005 std::cerr << "No change in magnitude range [" << m_viewMags[v].getMin() << "->" << m_viewMags[v].getMax() << "]" << std::endl;
|
Chris@184
|
2006 #endif
|
Chris@133
|
2007 }
|
Chris@133
|
2008
|
Chris@478
|
2009 if (recreateWholeImageCache) {
|
Chris@95
|
2010 x0 = 0;
|
Chris@95
|
2011 x1 = v->width();
|
Chris@95
|
2012 }
|
Chris@95
|
2013
|
Chris@215
|
2014 struct timeval tv;
|
Chris@215
|
2015 (void)gettimeofday(&tv, 0);
|
Chris@215
|
2016 RealTime mainPaintStart = RealTime::fromTimeval(tv);
|
Chris@215
|
2017
|
Chris@215
|
2018 int paintBlockWidth = m_lastPaintBlockWidth;
|
Chris@215
|
2019
|
Chris@389
|
2020 if (m_synchronous) {
|
Chris@389
|
2021 if (paintBlockWidth < x1 - x0) {
|
Chris@389
|
2022 // always paint full width
|
Chris@389
|
2023 paintBlockWidth = x1 - x0;
|
Chris@389
|
2024 }
|
Chris@215
|
2025 } else {
|
Chris@389
|
2026 if (paintBlockWidth == 0) {
|
Chris@389
|
2027 paintBlockWidth = (300000 / zoomLevel);
|
Chris@389
|
2028 } else {
|
Chris@389
|
2029 RealTime lastTime = m_lastPaintTime;
|
Chris@389
|
2030 while (lastTime > RealTime::fromMilliseconds(200) &&
|
Chris@389
|
2031 paintBlockWidth > 50) {
|
Chris@389
|
2032 paintBlockWidth /= 2;
|
Chris@389
|
2033 lastTime = lastTime / 2;
|
Chris@389
|
2034 }
|
Chris@389
|
2035 while (lastTime < RealTime::fromMilliseconds(90) &&
|
Chris@389
|
2036 paintBlockWidth < 1500) {
|
Chris@389
|
2037 paintBlockWidth *= 2;
|
Chris@389
|
2038 lastTime = lastTime * 2;
|
Chris@389
|
2039 }
|
Chris@215
|
2040 }
|
Chris@389
|
2041
|
Chris@389
|
2042 if (paintBlockWidth < 20) paintBlockWidth = 20;
|
Chris@215
|
2043 }
|
Chris@215
|
2044
|
Chris@224
|
2045 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@215
|
2046 std::cerr << "[" << this << "]: last paint width: " << m_lastPaintBlockWidth << ", last paint time: " << m_lastPaintTime << ", new paint width: " << paintBlockWidth << std::endl;
|
Chris@224
|
2047 #endif
|
Chris@224
|
2048
|
Chris@224
|
2049 // We always paint the full height when refreshing the cache.
|
Chris@224
|
2050 // Smaller heights can be used when painting direct from cache
|
Chris@224
|
2051 // (further up in this function), but we want to ensure the cache
|
Chris@224
|
2052 // is coherent without having to worry about vertical matching of
|
Chris@224
|
2053 // required and valid areas as well as horizontal.
|
Chris@224
|
2054
|
Chris@224
|
2055 int h = v->height();
|
Chris@215
|
2056
|
Chris@96
|
2057 if (cache.validArea.width() > 0) {
|
Chris@96
|
2058
|
Chris@331
|
2059 // If part of the cache is known to be valid, select a strip
|
Chris@331
|
2060 // immediately to left or right of the valid part
|
Chris@331
|
2061
|
Chris@481
|
2062 //!!! this really needs to be coordinated with the selection
|
Chris@481
|
2063 //!!! of m_drawBuffer boundaries in the bufferBinResolution
|
Chris@481
|
2064 //!!! case below
|
Chris@481
|
2065
|
Chris@96
|
2066 int vx0 = 0, vx1 = 0;
|
Chris@96
|
2067 vx0 = cache.validArea.x();
|
Chris@96
|
2068 vx1 = cache.validArea.x() + cache.validArea.width();
|
Chris@96
|
2069
|
Chris@96
|
2070 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@96
|
2071 std::cerr << "x0 " << x0 << ", x1 " << x1 << ", vx0 " << vx0 << ", vx1 " << vx1 << ", paintBlockWidth " << paintBlockWidth << std::endl;
|
Chris@331
|
2072 #endif
|
Chris@96
|
2073 if (x0 < vx0) {
|
Chris@96
|
2074 if (x0 + paintBlockWidth < vx0) {
|
Chris@96
|
2075 x0 = vx0 - paintBlockWidth;
|
Chris@331
|
2076 }
|
Chris@331
|
2077 x1 = vx0;
|
Chris@331
|
2078 } else if (x0 >= vx1) {
|
Chris@331
|
2079 x0 = vx1;
|
Chris@331
|
2080 if (x1 > x0 + paintBlockWidth) {
|
Chris@331
|
2081 x1 = x0 + paintBlockWidth;
|
Chris@331
|
2082 }
|
Chris@331
|
2083 } else {
|
Chris@331
|
2084 // x0 is within the valid area
|
Chris@331
|
2085 if (x1 > vx1) {
|
Chris@331
|
2086 x0 = vx1;
|
Chris@331
|
2087 if (x0 + paintBlockWidth < x1) {
|
Chris@331
|
2088 x1 = x0 + paintBlockWidth;
|
Chris@331
|
2089 }
|
Chris@96
|
2090 } else {
|
Chris@331
|
2091 x1 = x0; // it's all valid, paint nothing
|
Chris@95
|
2092 }
|
Chris@96
|
2093 }
|
Chris@331
|
2094
|
Chris@96
|
2095 cache.validArea = QRect
|
Chris@96
|
2096 (std::min(vx0, x0), cache.validArea.y(),
|
Chris@96
|
2097 std::max(vx1 - std::min(vx0, x0),
|
Chris@337
|
2098 x1 - std::min(vx0, x0)),
|
Chris@96
|
2099 cache.validArea.height());
|
Chris@337
|
2100
|
Chris@337
|
2101 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@337
|
2102 std::cerr << "Valid area becomes " << cache.validArea.x()
|
Chris@337
|
2103 << ", " << cache.validArea.y() << ", "
|
Chris@337
|
2104 << cache.validArea.width() << "x"
|
Chris@337
|
2105 << cache.validArea.height() << std::endl;
|
Chris@337
|
2106 #endif
|
Chris@95
|
2107
|
Chris@96
|
2108 } else {
|
Chris@96
|
2109 if (x1 > x0 + paintBlockWidth) {
|
Chris@133
|
2110 int sfx = x1;
|
Chris@133
|
2111 if (startFrame < 0) sfx = v->getXForFrame(0);
|
Chris@133
|
2112 if (sfx >= x0 && sfx + paintBlockWidth <= x1) {
|
Chris@133
|
2113 x0 = sfx;
|
Chris@133
|
2114 x1 = x0 + paintBlockWidth;
|
Chris@133
|
2115 } else {
|
Chris@133
|
2116 int mid = (x1 + x0) / 2;
|
Chris@133
|
2117 x0 = mid - paintBlockWidth/2;
|
Chris@133
|
2118 x1 = x0 + paintBlockWidth;
|
Chris@133
|
2119 }
|
Chris@95
|
2120 }
|
Chris@337
|
2121 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@337
|
2122 std::cerr << "Valid area becomes " << x0 << ", 0, " << (x1-x0)
|
Chris@337
|
2123 << "x" << h << std::endl;
|
Chris@337
|
2124 #endif
|
Chris@224
|
2125 cache.validArea = QRect(x0, 0, x1 - x0, h);
|
Chris@95
|
2126 }
|
Chris@95
|
2127
|
Chris@481
|
2128 /*
|
Chris@480
|
2129 if (xPixelRatio != 1.f) {
|
Chris@480
|
2130 x0 = int((int(x0 / xPixelRatio) - 4) * xPixelRatio + 0.0001);
|
Chris@480
|
2131 x1 = int((int(x1 / xPixelRatio) + 4) * xPixelRatio + 0.0001);
|
Chris@480
|
2132 }
|
Chris@481
|
2133 */
|
Chris@0
|
2134 int w = x1 - x0;
|
Chris@0
|
2135
|
Chris@95
|
2136 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@95
|
2137 std::cerr << "x0 " << x0 << ", x1 " << x1 << ", w " << w << ", h " << h << std::endl;
|
Chris@95
|
2138 #endif
|
Chris@95
|
2139
|
Chris@37
|
2140 int sr = m_model->getSampleRate();
|
Chris@122
|
2141
|
Chris@122
|
2142 // Set minFreq and maxFreq to the frequency extents of the possibly
|
Chris@122
|
2143 // zero-padded visible bin range, and displayMinFreq and displayMaxFreq
|
Chris@122
|
2144 // to the actual scale frequency extents (presumably not zero padded).
|
Chris@253
|
2145
|
Chris@253
|
2146 // If we are zero padding, we want to use the zero-padded
|
Chris@253
|
2147 // equivalents of the bins that we would be using if not zero
|
Chris@253
|
2148 // padded, to avoid spaces at the top and bottom of the display.
|
Chris@253
|
2149
|
Chris@253
|
2150 // Note fftSize is the actual zero-padded fft size, m_fftSize the
|
Chris@253
|
2151 // nominal fft size.
|
Chris@35
|
2152
|
Chris@253
|
2153 size_t maxbin = m_fftSize / 2;
|
Chris@35
|
2154 if (m_maxFrequency > 0) {
|
Chris@253
|
2155 maxbin = int((double(m_maxFrequency) * m_fftSize) / sr + 0.001);
|
Chris@253
|
2156 if (maxbin > m_fftSize / 2) maxbin = m_fftSize / 2;
|
Chris@35
|
2157 }
|
Chris@111
|
2158
|
Chris@40
|
2159 size_t minbin = 1;
|
Chris@37
|
2160 if (m_minFrequency > 0) {
|
Chris@253
|
2161 minbin = int((double(m_minFrequency) * m_fftSize) / sr + 0.001);
|
Chris@253
|
2162 // std::cerr << "m_minFrequency = " << m_minFrequency << " -> minbin = " << minbin << std::endl;
|
Chris@40
|
2163 if (minbin < 1) minbin = 1;
|
Chris@184
|
2164 if (minbin >= maxbin) minbin = maxbin - 1;
|
Chris@37
|
2165 }
|
Chris@37
|
2166
|
Chris@253
|
2167 int zpl = getZeroPadLevel(v) + 1;
|
Chris@253
|
2168 minbin = minbin * zpl;
|
Chris@253
|
2169 maxbin = (maxbin + 1) * zpl - 1;
|
Chris@253
|
2170
|
Chris@114
|
2171 float minFreq = (float(minbin) * sr) / fftSize;
|
Chris@184
|
2172 float maxFreq = (float(maxbin) * sr) / fftSize;
|
Chris@0
|
2173
|
Chris@122
|
2174 float displayMinFreq = minFreq;
|
Chris@122
|
2175 float displayMaxFreq = maxFreq;
|
Chris@122
|
2176
|
Chris@122
|
2177 if (fftSize != m_fftSize) {
|
Chris@122
|
2178 displayMinFreq = getEffectiveMinFrequency();
|
Chris@122
|
2179 displayMaxFreq = getEffectiveMaxFrequency();
|
Chris@122
|
2180 }
|
Chris@122
|
2181
|
Chris@253
|
2182 // std::cerr << "(giving actual minFreq " << minFreq << " and display minFreq " << displayMinFreq << ")" << std::endl;
|
Chris@253
|
2183
|
Chris@38
|
2184 size_t increment = getWindowIncrement();
|
Chris@40
|
2185
|
Chris@40
|
2186 bool logarithmic = (m_frequencyScale == LogFrequencyScale);
|
Chris@38
|
2187
|
Chris@481
|
2188 float yforbin[maxbin - minbin + 1];
|
Chris@481
|
2189
|
Chris@184
|
2190 for (size_t q = minbin; q <= maxbin; ++q) {
|
Chris@114
|
2191 float f0 = (float(q) * sr) / fftSize;
|
Chris@477
|
2192 yforbin[q - minbin] =
|
Chris@382
|
2193 v->getYForFrequency(f0, displayMinFreq, displayMaxFreq,
|
Chris@382
|
2194 logarithmic);
|
Chris@92
|
2195 }
|
Chris@92
|
2196
|
Chris@119
|
2197 MagnitudeRange overallMag = m_viewMags[v];
|
Chris@119
|
2198 bool overallMagChanged = false;
|
Chris@119
|
2199
|
Chris@162
|
2200 bool fftSuspended = false;
|
Chris@131
|
2201
|
Chris@137
|
2202 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@224
|
2203 std::cerr << ((float(v->getFrameForX(1) - v->getFrameForX(0))) / increment) << " bin(s) per pixel" << std::endl;
|
Chris@137
|
2204 #endif
|
Chris@137
|
2205
|
Chris@224
|
2206 bool runOutOfData = false;
|
Chris@224
|
2207
|
Chris@331
|
2208 if (w == 0) {
|
Chris@331
|
2209 std::cerr << "*** NOTE: w == 0" << std::endl;
|
Chris@331
|
2210 }
|
Chris@331
|
2211
|
Chris@331
|
2212 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@331
|
2213 size_t pixels = 0;
|
Chris@331
|
2214 #endif
|
Chris@331
|
2215
|
Chris@382
|
2216 Profiler outerprof("SpectrogramLayer::paint: all cols");
|
Chris@382
|
2217
|
Chris@481
|
2218 // The draw buffer contains a fragment at either our pixel
|
Chris@481
|
2219 // resolution (if there is more than one time-bin per pixel) or
|
Chris@481
|
2220 // time-bin resolution (if a time-bin spans more than one pixel).
|
Chris@481
|
2221 // We need to ensure that it starts and ends at points where a
|
Chris@481
|
2222 // time-bin boundary occurs at an exact pixel boundary, and with a
|
Chris@481
|
2223 // certain amount of overlap across existing pixels so that we can
|
Chris@481
|
2224 // scale and draw from it without smoothing errors at the edges.
|
Chris@481
|
2225
|
Chris@481
|
2226 // If (getFrameForX(x) / increment) * increment ==
|
Chris@481
|
2227 // getFrameForX(x), then x is a time-bin boundary. We want two
|
Chris@481
|
2228 // such boundaries at either side of the draw buffer -- one which
|
Chris@481
|
2229 // we draw up to, and one which we subsequently crop at.
|
Chris@481
|
2230
|
Chris@481
|
2231 bool bufferBinResolution = false;
|
Chris@481
|
2232 if (increment > zoomLevel) bufferBinResolution = true;
|
Chris@481
|
2233
|
Chris@481
|
2234 long leftBoundaryFrame = -1, leftCropFrame = -1;
|
Chris@481
|
2235 long rightBoundaryFrame = -1, rightCropFrame = -1;
|
Chris@481
|
2236
|
Chris@481
|
2237 int bufwid;
|
Chris@481
|
2238
|
Chris@481
|
2239 if (bufferBinResolution) {
|
Chris@481
|
2240
|
Chris@482
|
2241 for (int x = x0; ; --x) {
|
Chris@481
|
2242 long f = v->getFrameForX(x);
|
Chris@481
|
2243 if ((f / increment) * increment == f) {
|
Chris@481
|
2244 if (leftCropFrame == -1) leftCropFrame = f;
|
Chris@482
|
2245 else if (x < x0 - 2) { leftBoundaryFrame = f; break; }
|
Chris@481
|
2246 }
|
Chris@481
|
2247 }
|
Chris@482
|
2248 for (int x = x0 + w; ; ++x) {
|
Chris@481
|
2249 long f = v->getFrameForX(x);
|
Chris@481
|
2250 if ((f / increment) * increment == f) {
|
Chris@481
|
2251 if (rightCropFrame == -1) rightCropFrame = f;
|
Chris@482
|
2252 else if (x > x0 + w + 2) { rightBoundaryFrame = f; break; }
|
Chris@481
|
2253 }
|
Chris@481
|
2254 }
|
Chris@485
|
2255 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@481
|
2256 cerr << "Left: crop: " << leftCropFrame << " (bin " << leftCropFrame/increment << "); boundary: " << leftBoundaryFrame << " (bin " << leftBoundaryFrame/increment << ")" << endl;
|
Chris@481
|
2257 cerr << "Right: crop: " << rightCropFrame << " (bin " << rightCropFrame/increment << "); boundary: " << rightBoundaryFrame << " (bin " << rightBoundaryFrame/increment << ")" << endl;
|
Chris@485
|
2258 #endif
|
Chris@481
|
2259
|
Chris@481
|
2260 bufwid = (rightBoundaryFrame - leftBoundaryFrame) / increment;
|
Chris@481
|
2261
|
Chris@481
|
2262 } else {
|
Chris@481
|
2263
|
Chris@481
|
2264 bufwid = w;
|
Chris@481
|
2265 }
|
Chris@481
|
2266
|
Chris@481
|
2267 int binforx[bufwid];
|
Chris@481
|
2268 int binfory[h];
|
Chris@481
|
2269
|
Chris@484
|
2270 bool usePeaksCache = false;
|
Chris@484
|
2271
|
Chris@481
|
2272 if (bufferBinResolution) {
|
Chris@481
|
2273 for (int x = 0; x < bufwid; ++x) {
|
Chris@481
|
2274 binforx[x] = (leftBoundaryFrame / increment) + x;
|
Chris@482
|
2275 // cerr << "binforx[" << x << "] = " << binforx[x] << endl;
|
Chris@481
|
2276 }
|
Chris@481
|
2277 m_drawBuffer = QImage(bufwid, h, QImage::Format_Indexed8);
|
Chris@481
|
2278 } else {
|
Chris@481
|
2279 for (int x = 0; x < bufwid; ++x) {
|
Chris@481
|
2280 float s0 = 0, s1 = 0;
|
Chris@481
|
2281 if (getXBinRange(v, x + x0, s0, s1)) {
|
Chris@481
|
2282 binforx[x] = int(s0 + 0.0001);
|
Chris@481
|
2283 } else {
|
Chris@481
|
2284 binforx[x] = 0; //???
|
Chris@481
|
2285 }
|
Chris@481
|
2286 }
|
Chris@481
|
2287 if (m_drawBuffer.width() < bufwid || m_drawBuffer.height() < h) {
|
Chris@481
|
2288 m_drawBuffer = QImage(bufwid, h, QImage::Format_Indexed8);
|
Chris@480
|
2289 }
|
Chris@484
|
2290 usePeaksCache = (increment * 8) < zoomLevel;
|
Chris@480
|
2291 }
|
Chris@481
|
2292
|
Chris@481
|
2293 m_drawBuffer.setNumColors(256);
|
Chris@481
|
2294 for (int pixel = 0; pixel < 256; ++pixel) {
|
Chris@481
|
2295 m_drawBuffer.setColor(pixel, m_palette.getColour(pixel).rgb());
|
Chris@481
|
2296 }
|
Chris@481
|
2297
|
Chris@481
|
2298 m_drawBuffer.fill(0);
|
Chris@480
|
2299
|
Chris@480
|
2300 for (int y = 0; y < h; ++y) {
|
Chris@480
|
2301 float q0 = 0, q1 = 0;
|
Chris@486
|
2302 if (!getSmoothedYBinRange(v, h-y-1, q0, q1)) {
|
Chris@480
|
2303 binfory[y] = -1;
|
Chris@480
|
2304 } else {
|
Chris@480
|
2305 binfory[y] = int(q0 + 0.0001);
|
Chris@486
|
2306 cerr << "binfory[" << y << "] = " << binfory[y] << endl;
|
Chris@480
|
2307 }
|
Chris@480
|
2308 }
|
Chris@481
|
2309
|
Chris@484
|
2310 paintDrawBuffer(v, bufwid, h, binforx, binfory, usePeaksCache);
|
Chris@480
|
2311
|
Chris@480
|
2312 /*
|
Chris@479
|
2313 for (int x = 0; x < w / xPixelRatio; ++x) {
|
Chris@35
|
2314
|
Chris@382
|
2315 Profiler innerprof("SpectrogramLayer::paint: 1 pixel column");
|
Chris@382
|
2316
|
Chris@478
|
2317 runOutOfData = !paintColumnValues(v, fft, x0, x,
|
Chris@478
|
2318 minbin, maxbin,
|
Chris@478
|
2319 displayMinFreq, displayMaxFreq,
|
Chris@479
|
2320 xPixelRatio,
|
Chris@478
|
2321 h, yforbin);
|
Chris@477
|
2322
|
Chris@331
|
2323 if (runOutOfData) {
|
Chris@331
|
2324 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@331
|
2325 std::cerr << "Run out of data -- dropping out of loop" << std::endl;
|
Chris@331
|
2326 #endif
|
Chris@331
|
2327 break;
|
Chris@331
|
2328 }
|
Chris@35
|
2329 }
|
Chris@480
|
2330 */
|
Chris@331
|
2331 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@480
|
2332 // std::cerr << pixels << " pixels drawn" << std::endl;
|
Chris@331
|
2333 #endif
|
Chris@331
|
2334
|
Chris@119
|
2335 if (overallMagChanged) {
|
Chris@119
|
2336 m_viewMags[v] = overallMag;
|
Chris@209
|
2337 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@119
|
2338 std::cerr << "Overall mag is now [" << m_viewMags[v].getMin() << "->" << m_viewMags[v].getMax() << "] - will be updating" << std::endl;
|
Chris@209
|
2339 #endif
|
Chris@119
|
2340 } else {
|
Chris@209
|
2341 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@119
|
2342 std::cerr << "Overall mag unchanged at [" << m_viewMags[v].getMin() << "->" << m_viewMags[v].getMax() << "]" << std::endl;
|
Chris@209
|
2343 #endif
|
Chris@119
|
2344 }
|
Chris@119
|
2345
|
Chris@382
|
2346 outerprof.end();
|
Chris@382
|
2347
|
Chris@382
|
2348 Profiler profiler2("SpectrogramLayer::paint: draw image");
|
Chris@137
|
2349
|
Chris@478
|
2350 if (recreateWholeImageCache) {
|
Chris@407
|
2351 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@478
|
2352 std::cerr << "Recreating image cache: width = " << v->width()
|
Chris@331
|
2353 << ", height = " << h << std::endl;
|
Chris@407
|
2354 #endif
|
Chris@478
|
2355 cache.image = QImage(v->width(), h, QImage::Format_RGB32);
|
Chris@0
|
2356 }
|
Chris@0
|
2357
|
Chris@331
|
2358 if (w > 0) {
|
Chris@224
|
2359 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@481
|
2360 std::cerr << "Painting " << w << "x" << h
|
Chris@331
|
2361 << " from draw buffer at " << 0 << "," << 0
|
Chris@480
|
2362 << " to " << w << "x" << h << " on cache at "
|
Chris@480
|
2363 << x0 << "," << 0 << std::endl;
|
Chris@224
|
2364 #endif
|
Chris@224
|
2365
|
Chris@478
|
2366 QPainter cachePainter(&cache.image);
|
Chris@481
|
2367
|
Chris@481
|
2368 if (bufferBinResolution) {
|
Chris@481
|
2369 int scaledLeft = v->getXForFrame(leftBoundaryFrame);
|
Chris@481
|
2370 int scaledRight = v->getXForFrame(rightBoundaryFrame);
|
Chris@485
|
2371 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@481
|
2372 cerr << "Rescaling image from " << bufwid
|
Chris@481
|
2373 << "x" << h << " to "
|
Chris@481
|
2374 << scaledRight-scaledLeft << "x" << h << endl;
|
Chris@485
|
2375 #endif
|
Chris@481
|
2376 QImage scaled = m_drawBuffer.scaled
|
Chris@481
|
2377 (scaledRight - scaledLeft, h,
|
Chris@481
|
2378 Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
|
Chris@481
|
2379 // cachePainter.setRenderHint(QPainter::SmoothPixmapTransform, true);
|
Chris@481
|
2380 int scaledLeftCrop = v->getXForFrame(leftCropFrame);
|
Chris@481
|
2381 int scaledRightCrop = v->getXForFrame(rightCropFrame);
|
Chris@485
|
2382 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@481
|
2383 cerr << "Drawing image region of width " << scaledRightCrop - scaledLeftCrop << " to "
|
Chris@481
|
2384 << scaledLeftCrop << " from " << scaledLeftCrop - scaledLeft << endl;
|
Chris@485
|
2385 #endif
|
Chris@481
|
2386 cachePainter.drawImage
|
Chris@481
|
2387 (QRect(scaledLeftCrop, 0,
|
Chris@481
|
2388 scaledRightCrop - scaledLeftCrop, h),
|
Chris@481
|
2389 scaled,
|
Chris@481
|
2390 QRect(scaledLeftCrop - scaledLeft, 0,
|
Chris@481
|
2391 scaledRightCrop - scaledLeftCrop, h));
|
Chris@481
|
2392 } else {
|
Chris@481
|
2393 cachePainter.drawImage(QRect(x0, 0, w, h),
|
Chris@481
|
2394 m_drawBuffer,
|
Chris@481
|
2395 QRect(0, 0, w, h));
|
Chris@481
|
2396 }
|
Chris@481
|
2397
|
Chris@331
|
2398 cachePainter.end();
|
Chris@331
|
2399 }
|
Chris@331
|
2400
|
Chris@337
|
2401 QRect pr = rect & cache.validArea;
|
Chris@337
|
2402
|
Chris@337
|
2403 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@337
|
2404 std::cerr << "Painting " << pr.width() << "x" << pr.height()
|
Chris@337
|
2405 << " from cache at " << pr.x() << "," << pr.y()
|
Chris@337
|
2406 << " to window" << std::endl;
|
Chris@337
|
2407 #endif
|
Chris@337
|
2408
|
Chris@478
|
2409 paint.drawImage(pr.x(), pr.y(), cache.image,
|
Chris@479
|
2410 pr.x(), pr.y(), pr.width(), pr.height());
|
Chris@479
|
2411 //!!!
|
Chris@479
|
2412 // paint.drawImage(v->rect(), cache.image,
|
Chris@479
|
2413 // QRect(QPoint(0, 0), cache.image.size()));
|
Chris@337
|
2414
|
Chris@331
|
2415 cache.startFrame = startFrame;
|
Chris@331
|
2416 cache.zoomLevel = zoomLevel;
|
Chris@119
|
2417
|
Chris@389
|
2418 if (!m_synchronous) {
|
Chris@389
|
2419
|
Chris@389
|
2420 if (!m_normalizeVisibleArea || !overallMagChanged) {
|
Chris@0
|
2421
|
Chris@389
|
2422 if (cache.validArea.x() > 0) {
|
Chris@95
|
2423 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@389
|
2424 std::cerr << "SpectrogramLayer::paint() updating left (0, "
|
Chris@389
|
2425 << cache.validArea.x() << ")" << std::endl;
|
Chris@95
|
2426 #endif
|
Chris@389
|
2427 v->update(0, 0, cache.validArea.x(), h);
|
Chris@389
|
2428 }
|
Chris@389
|
2429
|
Chris@389
|
2430 if (cache.validArea.x() + cache.validArea.width() <
|
Chris@478
|
2431 cache.image.width()) {
|
Chris@389
|
2432 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@389
|
2433 std::cerr << "SpectrogramLayer::paint() updating right ("
|
Chris@389
|
2434 << cache.validArea.x() + cache.validArea.width()
|
Chris@389
|
2435 << ", "
|
Chris@478
|
2436 << cache.image.width() - (cache.validArea.x() +
|
Chris@389
|
2437 cache.validArea.width())
|
Chris@389
|
2438 << ")" << std::endl;
|
Chris@389
|
2439 #endif
|
Chris@389
|
2440 v->update(cache.validArea.x() + cache.validArea.width(),
|
Chris@389
|
2441 0,
|
Chris@478
|
2442 cache.image.width() - (cache.validArea.x() +
|
Chris@389
|
2443 cache.validArea.width()),
|
Chris@389
|
2444 h);
|
Chris@389
|
2445 }
|
Chris@389
|
2446 } else {
|
Chris@389
|
2447 // overallMagChanged
|
Chris@389
|
2448 std::cerr << "\noverallMagChanged - updating all\n" << std::endl;
|
Chris@389
|
2449 cache.validArea = QRect();
|
Chris@389
|
2450 v->update();
|
Chris@119
|
2451 }
|
Chris@95
|
2452 }
|
Chris@0
|
2453
|
Chris@121
|
2454 illuminateLocalFeatures(v, paint);
|
Chris@120
|
2455
|
Chris@0
|
2456 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@0
|
2457 std::cerr << "SpectrogramLayer::paint() returning" << std::endl;
|
Chris@0
|
2458 #endif
|
Chris@131
|
2459
|
Chris@389
|
2460 if (!m_synchronous) {
|
Chris@389
|
2461 m_lastPaintBlockWidth = paintBlockWidth;
|
Chris@389
|
2462 (void)gettimeofday(&tv, 0);
|
Chris@389
|
2463 m_lastPaintTime = RealTime::fromTimeval(tv) - mainPaintStart;
|
Chris@389
|
2464 }
|
Chris@215
|
2465
|
Chris@473
|
2466 //!!! if (fftSuspended) fft->resume();
|
Chris@0
|
2467 }
|
Chris@0
|
2468
|
Chris@480
|
2469 bool
|
Chris@481
|
2470 SpectrogramLayer::paintDrawBuffer(View *v,
|
Chris@481
|
2471 int w,
|
Chris@481
|
2472 int h,
|
Chris@481
|
2473 int *binforx,
|
Chris@484
|
2474 int *binfory,
|
Chris@484
|
2475 bool usePeaksCache) const
|
Chris@480
|
2476 {
|
Chris@481
|
2477 Profiler profiler("SpectrogramLayer::paintDrawBuffer");
|
Chris@480
|
2478
|
Chris@480
|
2479 int minbin = binfory[0];
|
Chris@480
|
2480 int maxbin = binfory[h-1];
|
Chris@480
|
2481
|
Chris@485
|
2482 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@481
|
2483 cerr << "minbin " << minbin << ", maxbin " << maxbin << "; w " << w << ", h " << h << endl;
|
Chris@485
|
2484 #endif
|
Chris@480
|
2485 if (minbin < 0) minbin = 0;
|
Chris@480
|
2486 if (maxbin < 0) maxbin = minbin+1;
|
Chris@480
|
2487
|
Chris@484
|
2488 DenseThreeDimensionalModel *sourceModel = 0;
|
Chris@484
|
2489 FFTModel *fft = 0;
|
Chris@484
|
2490 int divisor = 1;
|
Chris@485
|
2491 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@484
|
2492 cerr << "Note: bin display = " << m_binDisplay << ", w = " << w << ", binforx[" << w-1 << "] = " << binforx[w-1] << ", binforx[0] = " << binforx[0] << endl;
|
Chris@485
|
2493 #endif
|
Chris@484
|
2494 if (usePeaksCache) { //!!!
|
Chris@484
|
2495 sourceModel = getPeakCache(v);
|
Chris@484
|
2496 divisor = 8;//!!!
|
Chris@484
|
2497 minbin = 0;
|
Chris@484
|
2498 maxbin = sourceModel->getHeight();
|
Chris@484
|
2499 } else {
|
Chris@484
|
2500 sourceModel = fft = getFFTModel(v);
|
Chris@484
|
2501 }
|
Chris@484
|
2502
|
Chris@484
|
2503 if (!sourceModel) return false;
|
Chris@484
|
2504
|
Chris@480
|
2505 int psx = -1;
|
Chris@480
|
2506 float values[maxbin - minbin + 1];
|
Chris@484
|
2507 DenseThreeDimensionalModel::Column c;
|
Chris@483
|
2508 float peaks[h];
|
Chris@480
|
2509
|
Chris@480
|
2510 for (int x = 0; x < w; ++x) {
|
Chris@480
|
2511
|
Chris@482
|
2512 if (binforx[x] < 0) continue;
|
Chris@482
|
2513
|
Chris@484
|
2514 int sx0 = binforx[x] / divisor;
|
Chris@483
|
2515 int sx1 = sx0;
|
Chris@484
|
2516 if (x+1 < w) sx1 = binforx[x+1] / divisor;
|
Chris@483
|
2517 if (sx0 < 0) sx0 = sx1 - 1;
|
Chris@483
|
2518 if (sx0 < 0) continue;
|
Chris@483
|
2519 if (sx1 <= sx0) sx1 = sx0 + 1;
|
Chris@483
|
2520
|
Chris@483
|
2521 for (int y = 0; y < h; ++y) peaks[y] = 0.f;
|
Chris@480
|
2522
|
Chris@483
|
2523 for (int sx = sx0; sx < sx1; ++sx) {
|
Chris@483
|
2524
|
Chris@484
|
2525 if (sx < 0 || sx >= int(sourceModel->getWidth())) continue;
|
Chris@483
|
2526
|
Chris@483
|
2527 if (!m_synchronous) {
|
Chris@484
|
2528 if (!sourceModel->isColumnAvailable(sx)) {
|
Chris@480
|
2529 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@483
|
2530 std::cerr << "Met unavailable column at col " << sx << std::endl;
|
Chris@480
|
2531 #endif
|
Chris@483
|
2532 return false;
|
Chris@480
|
2533 }
|
Chris@483
|
2534 }
|
Chris@483
|
2535
|
Chris@483
|
2536 if (sx != psx) {
|
Chris@484
|
2537 if (fft) {
|
Chris@485
|
2538 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@484
|
2539 cerr << "Retrieving column " << sx << " from fft directly" << endl;
|
Chris@485
|
2540 #endif
|
Chris@484
|
2541 fft->getMagnitudesAt(sx, values, minbin, maxbin - minbin + 1);
|
Chris@484
|
2542 } else {
|
Chris@485
|
2543 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@484
|
2544 cerr << "Retrieving column " << sx << " from peaks cache" << endl;
|
Chris@485
|
2545 #endif
|
Chris@484
|
2546 c = sourceModel->getColumn(sx);
|
Chris@484
|
2547 }
|
Chris@483
|
2548 psx = sx;
|
Chris@483
|
2549 }
|
Chris@483
|
2550
|
Chris@483
|
2551 for (int y = 0; y < h; ++y) {
|
Chris@480
|
2552
|
Chris@480
|
2553 int sy0 = binfory[y];
|
Chris@481
|
2554 int sy1 = sy0;
|
Chris@481
|
2555 if (y+1 < h) sy1 = binfory[y+1];
|
Chris@480
|
2556 if (sy0 < 0) sy0 = sy1 - 1;
|
Chris@480
|
2557 if (sy0 < 0) continue;
|
Chris@480
|
2558 if (sy1 <= sy0) sy1 = sy0 + 1;
|
Chris@480
|
2559
|
Chris@480
|
2560 // cerr << "sy0 " << sy0 << " sy1 " << sy1 << endl;
|
Chris@480
|
2561
|
Chris@481
|
2562 //!!! review -- if we know we're dealing with
|
Chris@481
|
2563 //!!! magnitudes here, we can just use peak of the
|
Chris@481
|
2564 //!!! float values
|
Chris@481
|
2565
|
Chris@480
|
2566 for (int sy = sy0; sy < sy1; ++sy) {
|
Chris@480
|
2567
|
Chris@484
|
2568 float value = 0.f;
|
Chris@484
|
2569 if (fft) value = values[sy - minbin];
|
Chris@484
|
2570 else value = c[sy];
|
Chris@484
|
2571
|
Chris@481
|
2572 /*
|
Chris@480
|
2573 if (m_colourScale != PhaseColourScale) {
|
Chris@480
|
2574 if (!m_normalizeColumns) {
|
Chris@480
|
2575 value /= (m_fftSize/2.f);
|
Chris@480
|
2576 }
|
Chris@480
|
2577 //!!! mag.sample(value);
|
Chris@480
|
2578 value *= m_gain;
|
Chris@480
|
2579 }
|
Chris@480
|
2580
|
Chris@480
|
2581 unsigned char pix = getDisplayValue(v, value);
|
Chris@480
|
2582 if (pix > peakpix) peakpix = pix;
|
Chris@480
|
2583 // cerr <<x<<","<<y<<" -> "<<sx<<","<<sy<<" -> "<<values[sy]<<" -> "<<(int)pix<< endl;
|
Chris@481
|
2584 */
|
Chris@483
|
2585 if (value > peaks[y]) peaks[y] = value; //!!! not right for phase!
|
Chris@480
|
2586 }
|
Chris@483
|
2587 }
|
Chris@483
|
2588 }
|
Chris@483
|
2589
|
Chris@483
|
2590 for (int y = 0; y < h; ++y) {
|
Chris@483
|
2591
|
Chris@483
|
2592 float peak = peaks[y];
|
Chris@483
|
2593
|
Chris@483
|
2594 if (m_colourScale != PhaseColourScale) {
|
Chris@483
|
2595 if (!m_normalizeColumns) {
|
Chris@483
|
2596 peak /= (m_fftSize/2.f);
|
Chris@483
|
2597 }
|
Chris@481
|
2598 //!!! mag.sample(value);
|
Chris@483
|
2599 peak *= m_gain;
|
Chris@480
|
2600 }
|
Chris@483
|
2601
|
Chris@483
|
2602 unsigned char peakpix = getDisplayValue(v, peak);
|
Chris@480
|
2603
|
Chris@480
|
2604 m_drawBuffer.setPixel(x, h-y-1, peakpix);
|
Chris@480
|
2605 }
|
Chris@480
|
2606 }
|
Chris@480
|
2607
|
Chris@480
|
2608 return true;
|
Chris@480
|
2609 }
|
Chris@477
|
2610
|
Chris@477
|
2611 bool
|
Chris@478
|
2612 SpectrogramLayer::paintColumnValues(View *v,
|
Chris@477
|
2613 FFTModel *fft,
|
Chris@477
|
2614 int x0,
|
Chris@477
|
2615 int x,
|
Chris@477
|
2616 int minbin,
|
Chris@477
|
2617 int maxbin,
|
Chris@477
|
2618 float displayMinFreq,
|
Chris@477
|
2619 float displayMaxFreq,
|
Chris@479
|
2620 float xPixelRatio,
|
Chris@477
|
2621 const int h,
|
Chris@478
|
2622 const float *yforbin) const
|
Chris@477
|
2623 {
|
Chris@477
|
2624 float ymag[h];
|
Chris@477
|
2625 float ydiv[h];
|
Chris@477
|
2626 float values[maxbin - minbin + 1];
|
Chris@477
|
2627
|
Chris@477
|
2628 bool logarithmic = (m_frequencyScale == LogFrequencyScale);
|
Chris@477
|
2629
|
Chris@477
|
2630 bool interpolate = false;
|
Chris@477
|
2631 Preferences::SpectrogramSmoothing smoothing =
|
Chris@477
|
2632 Preferences::getInstance()->getSpectrogramSmoothing();
|
Chris@477
|
2633 if (smoothing == Preferences::SpectrogramInterpolated ||
|
Chris@477
|
2634 smoothing == Preferences::SpectrogramZeroPaddedAndInterpolated) {
|
Chris@477
|
2635 if (m_binDisplay != PeakBins &&
|
Chris@477
|
2636 m_binDisplay != PeakFrequencies) {
|
Chris@477
|
2637 interpolate = true;
|
Chris@477
|
2638 }
|
Chris@477
|
2639 }
|
Chris@477
|
2640
|
Chris@477
|
2641 for (int y = 0; y < h; ++y) {
|
Chris@477
|
2642 ymag[y] = 0.f;
|
Chris@477
|
2643 ydiv[y] = 0.f;
|
Chris@477
|
2644 }
|
Chris@477
|
2645
|
Chris@477
|
2646 float s0 = 0, s1 = 0;
|
Chris@477
|
2647
|
Chris@479
|
2648 if (!getXBinRange(v, x0 + x * xPixelRatio, s0, s1)) {
|
Chris@477
|
2649 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@480
|
2650 // std::cerr << "Out of range at " << x0 + x << std::endl;
|
Chris@477
|
2651 #endif
|
Chris@477
|
2652 assert(x <= m_drawBuffer.width());
|
Chris@478
|
2653 return true;
|
Chris@477
|
2654 }
|
Chris@477
|
2655
|
Chris@477
|
2656 int s0i = int(s0 + 0.001);
|
Chris@477
|
2657 int s1i = int(s1);
|
Chris@477
|
2658
|
Chris@477
|
2659 if (s1i >= int(fft->getWidth())) {
|
Chris@477
|
2660 if (s0i >= int(fft->getWidth())) {
|
Chris@477
|
2661 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@477
|
2662 std::cerr << "Column " << s0i << " out of range" << std::endl;
|
Chris@477
|
2663 #endif
|
Chris@478
|
2664 return true;
|
Chris@477
|
2665 } else {
|
Chris@477
|
2666 s1i = s0i;
|
Chris@477
|
2667 }
|
Chris@477
|
2668 }
|
Chris@477
|
2669
|
Chris@477
|
2670 FFTModel::PeakSet peaks;
|
Chris@477
|
2671
|
Chris@477
|
2672 for (int s = s0i; s <= s1i; ++s) {
|
Chris@477
|
2673
|
Chris@477
|
2674 if (!m_synchronous) {
|
Chris@477
|
2675 if (!fft->isColumnAvailable(s)) {
|
Chris@477
|
2676 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@477
|
2677 std::cerr << "Met unavailable column at col " << s << std::endl;
|
Chris@477
|
2678 #endif
|
Chris@477
|
2679 return false;
|
Chris@477
|
2680 }
|
Chris@477
|
2681 }
|
Chris@477
|
2682 /*!!!
|
Chris@477
|
2683 if (!fftSuspended) {
|
Chris@477
|
2684 fft->suspendWrites();
|
Chris@477
|
2685 fftSuspended = true;
|
Chris@477
|
2686 }
|
Chris@477
|
2687 */
|
Chris@477
|
2688 Profiler innerprof2("SpectrogramLayer::paint: 1 data column");
|
Chris@477
|
2689
|
Chris@477
|
2690 MagnitudeRange mag;
|
Chris@477
|
2691
|
Chris@477
|
2692 if (m_binDisplay == PeakFrequencies) {
|
Chris@477
|
2693 if (s < int(fft->getWidth()) - 1) {
|
Chris@477
|
2694 peaks = fft->getPeakFrequencies(FFTModel::AllPeaks,
|
Chris@477
|
2695 s,
|
Chris@477
|
2696 minbin, maxbin - 1);
|
Chris@477
|
2697 } else {
|
Chris@477
|
2698 peaks.clear();
|
Chris@477
|
2699 }
|
Chris@477
|
2700 }
|
Chris@477
|
2701
|
Chris@477
|
2702 if (m_colourScale == PhaseColourScale) {
|
Chris@477
|
2703 fft->getPhasesAt(s, values, minbin, maxbin - minbin + 1);
|
Chris@477
|
2704 } else if (m_normalizeColumns) {
|
Chris@477
|
2705 fft->getNormalizedMagnitudesAt(s, values, minbin, maxbin - minbin + 1);
|
Chris@477
|
2706 } else {
|
Chris@477
|
2707 fft->getMagnitudesAt(s, values, minbin, maxbin - minbin + 1);
|
Chris@477
|
2708 }
|
Chris@477
|
2709
|
Chris@477
|
2710 for (size_t q = minbin; q < maxbin; ++q) {
|
Chris@477
|
2711
|
Chris@477
|
2712 Profiler innerprof3("SpectrogramLayer::paint: 1 bin");
|
Chris@477
|
2713
|
Chris@477
|
2714 float y0 = yforbin[q + 1 - minbin];
|
Chris@477
|
2715 float y1 = yforbin[q - minbin];
|
Chris@477
|
2716
|
Chris@477
|
2717 if (m_binDisplay == PeakBins) {
|
Chris@477
|
2718 if (!fft->isLocalPeak(s, q)) continue;
|
Chris@477
|
2719 }
|
Chris@477
|
2720 if (m_binDisplay == PeakFrequencies) {
|
Chris@477
|
2721 if (peaks.find(q) == peaks.end()) continue;
|
Chris@477
|
2722 }
|
Chris@477
|
2723
|
Chris@477
|
2724 if (m_threshold != 0.f &&
|
Chris@477
|
2725 !fft->isOverThreshold(s, q, m_threshold * (m_fftSize/2))) {
|
Chris@477
|
2726 continue;
|
Chris@477
|
2727 }
|
Chris@477
|
2728
|
Chris@477
|
2729 float sprop = 1.f;
|
Chris@477
|
2730 if (s == s0i) sprop *= (s + 1) - s0;
|
Chris@477
|
2731 if (s == s1i) sprop *= s1 - s;
|
Chris@477
|
2732
|
Chris@477
|
2733 if (m_binDisplay == PeakFrequencies) {
|
Chris@477
|
2734 y0 = y1 = v->getYForFrequency
|
Chris@477
|
2735 (peaks[q], displayMinFreq, displayMaxFreq, logarithmic);
|
Chris@477
|
2736 }
|
Chris@477
|
2737
|
Chris@477
|
2738 int y0i = int(y0 + 0.001f);
|
Chris@477
|
2739 int y1i = int(y1);
|
Chris@477
|
2740
|
Chris@477
|
2741 float value = values[q - minbin];
|
Chris@477
|
2742
|
Chris@477
|
2743 if (m_colourScale != PhaseColourScale) {
|
Chris@477
|
2744 if (!m_normalizeColumns) {
|
Chris@477
|
2745 value /= (m_fftSize/2.f);
|
Chris@477
|
2746 }
|
Chris@477
|
2747 mag.sample(value);
|
Chris@477
|
2748 value *= m_gain;
|
Chris@477
|
2749 }
|
Chris@477
|
2750
|
Chris@477
|
2751 if (interpolate) {
|
Chris@477
|
2752
|
Chris@477
|
2753 int ypi = y0i;
|
Chris@477
|
2754 if (q < maxbin - 1) ypi = int(yforbin[q + 2 - minbin]);
|
Chris@477
|
2755
|
Chris@477
|
2756 for (int y = ypi; y <= y1i; ++y) {
|
Chris@477
|
2757
|
Chris@477
|
2758 if (y < 0 || y >= h) continue;
|
Chris@477
|
2759
|
Chris@477
|
2760 float yprop = sprop;
|
Chris@477
|
2761 float iprop = yprop;
|
Chris@477
|
2762
|
Chris@477
|
2763 if (ypi < y0i && y <= y0i) {
|
Chris@477
|
2764
|
Chris@477
|
2765 float half = float(y0i - ypi) / 2.f;
|
Chris@477
|
2766 float dist = y - (ypi + half);
|
Chris@477
|
2767
|
Chris@477
|
2768 if (dist >= 0) {
|
Chris@477
|
2769 iprop = (iprop * dist) / half;
|
Chris@477
|
2770 ymag[y] += iprop * value;
|
Chris@477
|
2771 }
|
Chris@477
|
2772 } else {
|
Chris@477
|
2773 if (y1i > y0i) {
|
Chris@477
|
2774
|
Chris@477
|
2775 float half = float(y1i - y0i) / 2.f;
|
Chris@477
|
2776 float dist = y - (y0i + half);
|
Chris@477
|
2777
|
Chris@477
|
2778 if (dist >= 0) {
|
Chris@477
|
2779 iprop = (iprop * (half - dist)) / half;
|
Chris@477
|
2780 }
|
Chris@477
|
2781 }
|
Chris@477
|
2782
|
Chris@477
|
2783 ymag[y] += iprop * value;
|
Chris@477
|
2784 ydiv[y] += yprop;
|
Chris@477
|
2785 }
|
Chris@477
|
2786 }
|
Chris@477
|
2787
|
Chris@477
|
2788 } else {
|
Chris@477
|
2789
|
Chris@477
|
2790 for (int y = y0i; y <= y1i; ++y) {
|
Chris@477
|
2791
|
Chris@477
|
2792 if (y < 0 || y >= h) continue;
|
Chris@477
|
2793
|
Chris@477
|
2794 float yprop = sprop;
|
Chris@477
|
2795 if (y == y0i) yprop *= (y + 1) - y0;
|
Chris@477
|
2796 if (y == y1i) yprop *= y1 - y;
|
Chris@477
|
2797
|
Chris@477
|
2798 for (int y = y0i; y <= y1i; ++y) {
|
Chris@477
|
2799
|
Chris@477
|
2800 if (y < 0 || y >= h) continue;
|
Chris@477
|
2801
|
Chris@477
|
2802 float yprop = sprop;
|
Chris@477
|
2803 if (y == y0i) yprop *= (y + 1.f) - y0;
|
Chris@477
|
2804 if (y == y1i) yprop *= y1 - y;
|
Chris@477
|
2805 ymag[y] += yprop * value;
|
Chris@477
|
2806 ydiv[y] += yprop;
|
Chris@477
|
2807 }
|
Chris@477
|
2808 }
|
Chris@477
|
2809 }
|
Chris@477
|
2810 }
|
Chris@477
|
2811
|
Chris@477
|
2812 if (mag.isSet()) {
|
Chris@477
|
2813
|
Chris@477
|
2814 if (s >= int(m_columnMags.size())) {
|
Chris@477
|
2815 std::cerr << "INTERNAL ERROR: " << s << " >= "
|
Chris@477
|
2816 << m_columnMags.size() << " at SpectrogramLayer.cpp:2087" << std::endl;
|
Chris@477
|
2817 }
|
Chris@477
|
2818
|
Chris@477
|
2819 m_columnMags[s].sample(mag);
|
Chris@477
|
2820 /*!!!
|
Chris@477
|
2821 if (overallMag.sample(mag)) {
|
Chris@477
|
2822 //!!! scaling would change here
|
Chris@477
|
2823 overallMagChanged = true;
|
Chris@477
|
2824 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@477
|
2825 std::cerr << "Overall mag changed (again?) at column " << s << ", to [" << overallMag.getMin() << "->" << overallMag.getMax() << "]" << std::endl;
|
Chris@477
|
2826 #endif
|
Chris@477
|
2827 }
|
Chris@477
|
2828 */
|
Chris@477
|
2829 }
|
Chris@477
|
2830 }
|
Chris@477
|
2831
|
Chris@477
|
2832 for (int y = 0; y < h; ++y) {
|
Chris@477
|
2833
|
Chris@478
|
2834 float value = 0.f;
|
Chris@478
|
2835
|
Chris@477
|
2836 if (ydiv[y] > 0.0) {
|
Chris@478
|
2837 value = ymag[y] / ydiv[y];
|
Chris@477
|
2838 }
|
Chris@478
|
2839
|
Chris@478
|
2840 unsigned char pixel = getDisplayValue(v, value);
|
Chris@478
|
2841 m_drawBuffer.setPixel(x, y, pixel);
|
Chris@477
|
2842 }
|
Chris@477
|
2843
|
Chris@477
|
2844 return true;
|
Chris@477
|
2845 }
|
Chris@477
|
2846
|
Chris@477
|
2847
|
Chris@121
|
2848 void
|
Chris@121
|
2849 SpectrogramLayer::illuminateLocalFeatures(View *v, QPainter &paint) const
|
Chris@121
|
2850 {
|
Chris@382
|
2851 Profiler profiler("SpectrogramLayer::illuminateLocalFeatures");
|
Chris@382
|
2852
|
Chris@121
|
2853 QPoint localPos;
|
Chris@121
|
2854 if (!v->shouldIlluminateLocalFeatures(this, localPos) || !m_model) {
|
Chris@121
|
2855 return;
|
Chris@121
|
2856 }
|
Chris@121
|
2857
|
Chris@180
|
2858 // std::cerr << "SpectrogramLayer: illuminateLocalFeatures("
|
Chris@180
|
2859 // << localPos.x() << "," << localPos.y() << ")" << std::endl;
|
Chris@121
|
2860
|
Chris@121
|
2861 float s0, s1;
|
Chris@121
|
2862 float f0, f1;
|
Chris@121
|
2863
|
Chris@121
|
2864 if (getXBinRange(v, localPos.x(), s0, s1) &&
|
Chris@121
|
2865 getYBinSourceRange(v, localPos.y(), f0, f1)) {
|
Chris@121
|
2866
|
Chris@121
|
2867 int s0i = int(s0 + 0.001);
|
Chris@121
|
2868 int s1i = int(s1);
|
Chris@121
|
2869
|
Chris@121
|
2870 int x0 = v->getXForFrame(s0i * getWindowIncrement());
|
Chris@121
|
2871 int x1 = v->getXForFrame((s1i + 1) * getWindowIncrement());
|
Chris@121
|
2872
|
Chris@248
|
2873 int y1 = int(getYForFrequency(v, f1));
|
Chris@248
|
2874 int y0 = int(getYForFrequency(v, f0));
|
Chris@121
|
2875
|
Chris@180
|
2876 // std::cerr << "SpectrogramLayer: illuminate "
|
Chris@180
|
2877 // << x0 << "," << y1 << " -> " << x1 << "," << y0 << std::endl;
|
Chris@121
|
2878
|
Chris@287
|
2879 paint.setPen(v->getForeground());
|
Chris@133
|
2880
|
Chris@133
|
2881 //!!! should we be using paintCrosshairs for this?
|
Chris@133
|
2882
|
Chris@121
|
2883 paint.drawRect(x0, y1, x1 - x0 + 1, y0 - y1 + 1);
|
Chris@121
|
2884 }
|
Chris@121
|
2885 }
|
Chris@121
|
2886
|
Chris@42
|
2887 float
|
Chris@267
|
2888 SpectrogramLayer::getYForFrequency(const View *v, float frequency) const
|
Chris@42
|
2889 {
|
Chris@44
|
2890 return v->getYForFrequency(frequency,
|
Chris@44
|
2891 getEffectiveMinFrequency(),
|
Chris@44
|
2892 getEffectiveMaxFrequency(),
|
Chris@44
|
2893 m_frequencyScale == LogFrequencyScale);
|
Chris@42
|
2894 }
|
Chris@42
|
2895
|
Chris@42
|
2896 float
|
Chris@267
|
2897 SpectrogramLayer::getFrequencyForY(const View *v, int y) const
|
Chris@42
|
2898 {
|
Chris@44
|
2899 return v->getFrequencyForY(y,
|
Chris@44
|
2900 getEffectiveMinFrequency(),
|
Chris@44
|
2901 getEffectiveMaxFrequency(),
|
Chris@44
|
2902 m_frequencyScale == LogFrequencyScale);
|
Chris@42
|
2903 }
|
Chris@42
|
2904
|
Chris@0
|
2905 int
|
Chris@115
|
2906 SpectrogramLayer::getCompletion(View *v) const
|
Chris@0
|
2907 {
|
Chris@115
|
2908 if (m_updateTimer == 0) return 100;
|
Chris@130
|
2909 if (m_fftModels.find(v) == m_fftModels.end()) return 100;
|
Chris@130
|
2910
|
Chris@130
|
2911 size_t completion = m_fftModels[v].first->getCompletion();
|
Chris@224
|
2912 #ifdef DEBUG_SPECTROGRAM_REPAINT
|
Chris@115
|
2913 std::cerr << "SpectrogramLayer::getCompletion: completion = " << completion << std::endl;
|
Chris@224
|
2914 #endif
|
Chris@0
|
2915 return completion;
|
Chris@0
|
2916 }
|
Chris@0
|
2917
|
Chris@28
|
2918 bool
|
Chris@101
|
2919 SpectrogramLayer::getValueExtents(float &min, float &max,
|
Chris@101
|
2920 bool &logarithmic, QString &unit) const
|
Chris@79
|
2921 {
|
Chris@133
|
2922 if (!m_model) return false;
|
Chris@133
|
2923
|
Chris@133
|
2924 int sr = m_model->getSampleRate();
|
Chris@133
|
2925 min = float(sr) / m_fftSize;
|
Chris@133
|
2926 max = float(sr) / 2;
|
Chris@133
|
2927
|
Chris@101
|
2928 logarithmic = (m_frequencyScale == LogFrequencyScale);
|
Chris@79
|
2929 unit = "Hz";
|
Chris@79
|
2930 return true;
|
Chris@79
|
2931 }
|
Chris@79
|
2932
|
Chris@79
|
2933 bool
|
Chris@101
|
2934 SpectrogramLayer::getDisplayExtents(float &min, float &max) const
|
Chris@101
|
2935 {
|
Chris@101
|
2936 min = getEffectiveMinFrequency();
|
Chris@101
|
2937 max = getEffectiveMaxFrequency();
|
Chris@253
|
2938
|
Chris@248
|
2939 // std::cerr << "SpectrogramLayer::getDisplayExtents: " << min << "->" << max << std::endl;
|
Chris@101
|
2940 return true;
|
Chris@101
|
2941 }
|
Chris@101
|
2942
|
Chris@101
|
2943 bool
|
Chris@120
|
2944 SpectrogramLayer::setDisplayExtents(float min, float max)
|
Chris@120
|
2945 {
|
Chris@120
|
2946 if (!m_model) return false;
|
Chris@187
|
2947
|
Chris@253
|
2948 // std::cerr << "SpectrogramLayer::setDisplayExtents: " << min << "->" << max << std::endl;
|
Chris@187
|
2949
|
Chris@120
|
2950 if (min < 0) min = 0;
|
Chris@120
|
2951 if (max > m_model->getSampleRate()/2) max = m_model->getSampleRate()/2;
|
Chris@120
|
2952
|
Chris@120
|
2953 size_t minf = lrintf(min);
|
Chris@120
|
2954 size_t maxf = lrintf(max);
|
Chris@120
|
2955
|
Chris@120
|
2956 if (m_minFrequency == minf && m_maxFrequency == maxf) return true;
|
Chris@120
|
2957
|
Chris@478
|
2958 invalidateImageCaches();
|
Chris@120
|
2959 invalidateMagnitudes();
|
Chris@120
|
2960
|
Chris@120
|
2961 m_minFrequency = minf;
|
Chris@120
|
2962 m_maxFrequency = maxf;
|
Chris@120
|
2963
|
Chris@120
|
2964 emit layerParametersChanged();
|
Chris@120
|
2965
|
Chris@133
|
2966 int vs = getCurrentVerticalZoomStep();
|
Chris@133
|
2967 if (vs != m_lastEmittedZoomStep) {
|
Chris@133
|
2968 emit verticalZoomChanged();
|
Chris@133
|
2969 m_lastEmittedZoomStep = vs;
|
Chris@133
|
2970 }
|
Chris@133
|
2971
|
Chris@120
|
2972 return true;
|
Chris@120
|
2973 }
|
Chris@120
|
2974
|
Chris@120
|
2975 bool
|
Chris@267
|
2976 SpectrogramLayer::getYScaleValue(const View *v, int y,
|
Chris@261
|
2977 float &value, QString &unit) const
|
Chris@261
|
2978 {
|
Chris@261
|
2979 value = getFrequencyForY(v, y);
|
Chris@261
|
2980 unit = "Hz";
|
Chris@261
|
2981 return true;
|
Chris@261
|
2982 }
|
Chris@261
|
2983
|
Chris@261
|
2984 bool
|
Chris@248
|
2985 SpectrogramLayer::snapToFeatureFrame(View *, int &frame,
|
Chris@28
|
2986 size_t &resolution,
|
Chris@28
|
2987 SnapType snap) const
|
Chris@13
|
2988 {
|
Chris@13
|
2989 resolution = getWindowIncrement();
|
Chris@28
|
2990 int left = (frame / resolution) * resolution;
|
Chris@28
|
2991 int right = left + resolution;
|
Chris@28
|
2992
|
Chris@28
|
2993 switch (snap) {
|
Chris@28
|
2994 case SnapLeft: frame = left; break;
|
Chris@28
|
2995 case SnapRight: frame = right; break;
|
Chris@28
|
2996 case SnapNearest:
|
Chris@28
|
2997 case SnapNeighbouring:
|
Chris@28
|
2998 if (frame - left > right - frame) frame = right;
|
Chris@28
|
2999 else frame = left;
|
Chris@28
|
3000 break;
|
Chris@28
|
3001 }
|
Chris@28
|
3002
|
Chris@28
|
3003 return true;
|
Chris@28
|
3004 }
|
Chris@13
|
3005
|
Chris@283
|
3006 void
|
Chris@283
|
3007 SpectrogramLayer::measureDoubleClick(View *v, QMouseEvent *e)
|
Chris@283
|
3008 {
|
Chris@478
|
3009 ImageCache &cache = m_imageCaches[v];
|
Chris@478
|
3010
|
Chris@478
|
3011 std::cerr << "cache width: " << cache.image.width() << ", height: "
|
Chris@478
|
3012 << cache.image.height() << std::endl;
|
Chris@478
|
3013
|
Chris@478
|
3014 QImage image = cache.image;
|
Chris@283
|
3015
|
Chris@283
|
3016 ImageRegionFinder finder;
|
Chris@283
|
3017 QRect rect = finder.findRegionExtents(&image, e->pos());
|
Chris@283
|
3018 if (rect.isValid()) {
|
Chris@283
|
3019 MeasureRect mr;
|
Chris@283
|
3020 setMeasureRectFromPixrect(v, mr, rect);
|
Chris@283
|
3021 CommandHistory::getInstance()->addCommand
|
Chris@283
|
3022 (new AddMeasurementRectCommand(this, mr));
|
Chris@283
|
3023 }
|
Chris@283
|
3024 }
|
Chris@283
|
3025
|
Chris@77
|
3026 bool
|
Chris@264
|
3027 SpectrogramLayer::getCrosshairExtents(View *v, QPainter &paint,
|
Chris@77
|
3028 QPoint cursorPos,
|
Chris@77
|
3029 std::vector<QRect> &extents) const
|
Chris@77
|
3030 {
|
Chris@77
|
3031 QRect vertical(cursorPos.x() - 12, 0, 12, v->height());
|
Chris@77
|
3032 extents.push_back(vertical);
|
Chris@77
|
3033
|
Chris@77
|
3034 QRect horizontal(0, cursorPos.y(), cursorPos.x(), 1);
|
Chris@77
|
3035 extents.push_back(horizontal);
|
Chris@77
|
3036
|
Chris@264
|
3037 int sw = getVerticalScaleWidth(v, paint);
|
Chris@264
|
3038
|
Chris@280
|
3039 QRect freq(sw, cursorPos.y() - paint.fontMetrics().ascent() - 2,
|
Chris@280
|
3040 paint.fontMetrics().width("123456 Hz") + 2,
|
Chris@280
|
3041 paint.fontMetrics().height());
|
Chris@280
|
3042 extents.push_back(freq);
|
Chris@264
|
3043
|
Chris@279
|
3044 QRect pitch(sw, cursorPos.y() + 2,
|
Chris@279
|
3045 paint.fontMetrics().width("C#10+50c") + 2,
|
Chris@279
|
3046 paint.fontMetrics().height());
|
Chris@279
|
3047 extents.push_back(pitch);
|
Chris@279
|
3048
|
Chris@280
|
3049 QRect rt(cursorPos.x(),
|
Chris@280
|
3050 v->height() - paint.fontMetrics().height() - 2,
|
Chris@280
|
3051 paint.fontMetrics().width("1234.567 s"),
|
Chris@280
|
3052 paint.fontMetrics().height());
|
Chris@280
|
3053 extents.push_back(rt);
|
Chris@280
|
3054
|
Chris@280
|
3055 int w(paint.fontMetrics().width("1234567890") + 2);
|
Chris@280
|
3056 QRect frame(cursorPos.x() - w - 2,
|
Chris@280
|
3057 v->height() - paint.fontMetrics().height() - 2,
|
Chris@280
|
3058 w,
|
Chris@280
|
3059 paint.fontMetrics().height());
|
Chris@280
|
3060 extents.push_back(frame);
|
Chris@280
|
3061
|
Chris@77
|
3062 return true;
|
Chris@77
|
3063 }
|
Chris@77
|
3064
|
Chris@77
|
3065 void
|
Chris@77
|
3066 SpectrogramLayer::paintCrosshairs(View *v, QPainter &paint,
|
Chris@77
|
3067 QPoint cursorPos) const
|
Chris@77
|
3068 {
|
Chris@77
|
3069 paint.save();
|
Chris@283
|
3070
|
Chris@283
|
3071 int sw = getVerticalScaleWidth(v, paint);
|
Chris@283
|
3072
|
Chris@282
|
3073 QFont fn = paint.font();
|
Chris@282
|
3074 if (fn.pointSize() > 8) {
|
Chris@282
|
3075 fn.setPointSize(fn.pointSize() - 1);
|
Chris@282
|
3076 paint.setFont(fn);
|
Chris@282
|
3077 }
|
Chris@77
|
3078 paint.setPen(m_crosshairColour);
|
Chris@77
|
3079
|
Chris@77
|
3080 paint.drawLine(0, cursorPos.y(), cursorPos.x() - 1, cursorPos.y());
|
Chris@77
|
3081 paint.drawLine(cursorPos.x(), 0, cursorPos.x(), v->height());
|
Chris@77
|
3082
|
Chris@77
|
3083 float fundamental = getFrequencyForY(v, cursorPos.y());
|
Chris@77
|
3084
|
Chris@278
|
3085 v->drawVisibleText(paint,
|
Chris@278
|
3086 sw + 2,
|
Chris@278
|
3087 cursorPos.y() - 2,
|
Chris@278
|
3088 QString("%1 Hz").arg(fundamental),
|
Chris@278
|
3089 View::OutlinedText);
|
Chris@278
|
3090
|
Chris@279
|
3091 if (Pitch::isFrequencyInMidiRange(fundamental)) {
|
Chris@279
|
3092 QString pitchLabel = Pitch::getPitchLabelForFrequency(fundamental);
|
Chris@279
|
3093 v->drawVisibleText(paint,
|
Chris@279
|
3094 sw + 2,
|
Chris@279
|
3095 cursorPos.y() + paint.fontMetrics().ascent() + 2,
|
Chris@279
|
3096 pitchLabel,
|
Chris@279
|
3097 View::OutlinedText);
|
Chris@279
|
3098 }
|
Chris@279
|
3099
|
Chris@280
|
3100 long frame = v->getFrameForX(cursorPos.x());
|
Chris@279
|
3101 RealTime rt = RealTime::frame2RealTime(frame, m_model->getSampleRate());
|
Chris@280
|
3102 QString rtLabel = QString("%1 s").arg(rt.toText(true).c_str());
|
Chris@280
|
3103 QString frameLabel = QString("%1").arg(frame);
|
Chris@280
|
3104 v->drawVisibleText(paint,
|
Chris@280
|
3105 cursorPos.x() - paint.fontMetrics().width(frameLabel) - 2,
|
Chris@280
|
3106 v->height() - 2,
|
Chris@280
|
3107 frameLabel,
|
Chris@280
|
3108 View::OutlinedText);
|
Chris@280
|
3109 v->drawVisibleText(paint,
|
Chris@280
|
3110 cursorPos.x() + 2,
|
Chris@280
|
3111 v->height() - 2,
|
Chris@280
|
3112 rtLabel,
|
Chris@280
|
3113 View::OutlinedText);
|
Chris@264
|
3114
|
Chris@77
|
3115 int harmonic = 2;
|
Chris@77
|
3116
|
Chris@77
|
3117 while (harmonic < 100) {
|
Chris@77
|
3118
|
Chris@77
|
3119 float hy = lrintf(getYForFrequency(v, fundamental * harmonic));
|
Chris@77
|
3120 if (hy < 0 || hy > v->height()) break;
|
Chris@77
|
3121
|
Chris@77
|
3122 int len = 7;
|
Chris@77
|
3123
|
Chris@77
|
3124 if (harmonic % 2 == 0) {
|
Chris@77
|
3125 if (harmonic % 4 == 0) {
|
Chris@77
|
3126 len = 12;
|
Chris@77
|
3127 } else {
|
Chris@77
|
3128 len = 10;
|
Chris@77
|
3129 }
|
Chris@77
|
3130 }
|
Chris@77
|
3131
|
Chris@77
|
3132 paint.drawLine(cursorPos.x() - len,
|
Chris@248
|
3133 int(hy),
|
Chris@77
|
3134 cursorPos.x(),
|
Chris@248
|
3135 int(hy));
|
Chris@77
|
3136
|
Chris@77
|
3137 ++harmonic;
|
Chris@77
|
3138 }
|
Chris@77
|
3139
|
Chris@77
|
3140 paint.restore();
|
Chris@77
|
3141 }
|
Chris@77
|
3142
|
Chris@25
|
3143 QString
|
Chris@44
|
3144 SpectrogramLayer::getFeatureDescription(View *v, QPoint &pos) const
|
Chris@25
|
3145 {
|
Chris@25
|
3146 int x = pos.x();
|
Chris@25
|
3147 int y = pos.y();
|
Chris@0
|
3148
|
Chris@25
|
3149 if (!m_model || !m_model->isOK()) return "";
|
Chris@0
|
3150
|
Chris@38
|
3151 float magMin = 0, magMax = 0;
|
Chris@38
|
3152 float phaseMin = 0, phaseMax = 0;
|
Chris@0
|
3153 float freqMin = 0, freqMax = 0;
|
Chris@35
|
3154 float adjFreqMin = 0, adjFreqMax = 0;
|
Chris@25
|
3155 QString pitchMin, pitchMax;
|
Chris@0
|
3156 RealTime rtMin, rtMax;
|
Chris@0
|
3157
|
Chris@38
|
3158 bool haveValues = false;
|
Chris@0
|
3159
|
Chris@44
|
3160 if (!getXBinSourceRange(v, x, rtMin, rtMax)) {
|
Chris@38
|
3161 return "";
|
Chris@38
|
3162 }
|
Chris@44
|
3163 if (getXYBinSourceRange(v, x, y, magMin, magMax, phaseMin, phaseMax)) {
|
Chris@38
|
3164 haveValues = true;
|
Chris@38
|
3165 }
|
Chris@0
|
3166
|
Chris@35
|
3167 QString adjFreqText = "", adjPitchText = "";
|
Chris@35
|
3168
|
Chris@38
|
3169 if (m_binDisplay == PeakFrequencies) {
|
Chris@35
|
3170
|
Chris@44
|
3171 if (!getAdjustedYBinSourceRange(v, x, y, freqMin, freqMax,
|
Chris@38
|
3172 adjFreqMin, adjFreqMax)) {
|
Chris@38
|
3173 return "";
|
Chris@38
|
3174 }
|
Chris@35
|
3175
|
Chris@35
|
3176 if (adjFreqMin != adjFreqMax) {
|
Chris@65
|
3177 adjFreqText = tr("Peak Frequency:\t%1 - %2 Hz\n")
|
Chris@35
|
3178 .arg(adjFreqMin).arg(adjFreqMax);
|
Chris@35
|
3179 } else {
|
Chris@65
|
3180 adjFreqText = tr("Peak Frequency:\t%1 Hz\n")
|
Chris@35
|
3181 .arg(adjFreqMin);
|
Chris@38
|
3182 }
|
Chris@38
|
3183
|
Chris@38
|
3184 QString pmin = Pitch::getPitchLabelForFrequency(adjFreqMin);
|
Chris@38
|
3185 QString pmax = Pitch::getPitchLabelForFrequency(adjFreqMax);
|
Chris@38
|
3186
|
Chris@38
|
3187 if (pmin != pmax) {
|
Chris@65
|
3188 adjPitchText = tr("Peak Pitch:\t%3 - %4\n").arg(pmin).arg(pmax);
|
Chris@38
|
3189 } else {
|
Chris@65
|
3190 adjPitchText = tr("Peak Pitch:\t%2\n").arg(pmin);
|
Chris@35
|
3191 }
|
Chris@35
|
3192
|
Chris@35
|
3193 } else {
|
Chris@35
|
3194
|
Chris@44
|
3195 if (!getYBinSourceRange(v, y, freqMin, freqMax)) return "";
|
Chris@35
|
3196 }
|
Chris@35
|
3197
|
Chris@25
|
3198 QString text;
|
Chris@25
|
3199
|
Chris@25
|
3200 if (rtMin != rtMax) {
|
Chris@25
|
3201 text += tr("Time:\t%1 - %2\n")
|
Chris@25
|
3202 .arg(rtMin.toText(true).c_str())
|
Chris@25
|
3203 .arg(rtMax.toText(true).c_str());
|
Chris@25
|
3204 } else {
|
Chris@25
|
3205 text += tr("Time:\t%1\n")
|
Chris@25
|
3206 .arg(rtMin.toText(true).c_str());
|
Chris@0
|
3207 }
|
Chris@0
|
3208
|
Chris@25
|
3209 if (freqMin != freqMax) {
|
Chris@65
|
3210 text += tr("%1Bin Frequency:\t%2 - %3 Hz\n%4Bin Pitch:\t%5 - %6\n")
|
Chris@65
|
3211 .arg(adjFreqText)
|
Chris@25
|
3212 .arg(freqMin)
|
Chris@25
|
3213 .arg(freqMax)
|
Chris@65
|
3214 .arg(adjPitchText)
|
Chris@65
|
3215 .arg(Pitch::getPitchLabelForFrequency(freqMin))
|
Chris@65
|
3216 .arg(Pitch::getPitchLabelForFrequency(freqMax));
|
Chris@65
|
3217 } else {
|
Chris@65
|
3218 text += tr("%1Bin Frequency:\t%2 Hz\n%3Bin Pitch:\t%4\n")
|
Chris@35
|
3219 .arg(adjFreqText)
|
Chris@25
|
3220 .arg(freqMin)
|
Chris@65
|
3221 .arg(adjPitchText)
|
Chris@65
|
3222 .arg(Pitch::getPitchLabelForFrequency(freqMin));
|
Chris@25
|
3223 }
|
Chris@25
|
3224
|
Chris@38
|
3225 if (haveValues) {
|
Chris@38
|
3226 float dbMin = AudioLevel::multiplier_to_dB(magMin);
|
Chris@38
|
3227 float dbMax = AudioLevel::multiplier_to_dB(magMax);
|
Chris@43
|
3228 QString dbMinString;
|
Chris@43
|
3229 QString dbMaxString;
|
Chris@43
|
3230 if (dbMin == AudioLevel::DB_FLOOR) {
|
Chris@43
|
3231 dbMinString = tr("-Inf");
|
Chris@43
|
3232 } else {
|
Chris@43
|
3233 dbMinString = QString("%1").arg(lrintf(dbMin));
|
Chris@43
|
3234 }
|
Chris@43
|
3235 if (dbMax == AudioLevel::DB_FLOOR) {
|
Chris@43
|
3236 dbMaxString = tr("-Inf");
|
Chris@43
|
3237 } else {
|
Chris@43
|
3238 dbMaxString = QString("%1").arg(lrintf(dbMax));
|
Chris@43
|
3239 }
|
Chris@25
|
3240 if (lrintf(dbMin) != lrintf(dbMax)) {
|
Chris@199
|
3241 text += tr("dB:\t%1 - %2").arg(dbMinString).arg(dbMaxString);
|
Chris@25
|
3242 } else {
|
Chris@199
|
3243 text += tr("dB:\t%1").arg(dbMinString);
|
Chris@25
|
3244 }
|
Chris@38
|
3245 if (phaseMin != phaseMax) {
|
Chris@38
|
3246 text += tr("\nPhase:\t%1 - %2").arg(phaseMin).arg(phaseMax);
|
Chris@38
|
3247 } else {
|
Chris@38
|
3248 text += tr("\nPhase:\t%1").arg(phaseMin);
|
Chris@38
|
3249 }
|
Chris@25
|
3250 }
|
Chris@25
|
3251
|
Chris@25
|
3252 return text;
|
Chris@0
|
3253 }
|
Chris@25
|
3254
|
Chris@0
|
3255 int
|
Chris@40
|
3256 SpectrogramLayer::getColourScaleWidth(QPainter &paint) const
|
Chris@40
|
3257 {
|
Chris@40
|
3258 int cw;
|
Chris@40
|
3259
|
Chris@119
|
3260 cw = paint.fontMetrics().width("-80dB");
|
Chris@119
|
3261
|
Chris@40
|
3262 return cw;
|
Chris@40
|
3263 }
|
Chris@40
|
3264
|
Chris@40
|
3265 int
|
Chris@248
|
3266 SpectrogramLayer::getVerticalScaleWidth(View *, QPainter &paint) const
|
Chris@0
|
3267 {
|
Chris@0
|
3268 if (!m_model || !m_model->isOK()) return 0;
|
Chris@0
|
3269
|
Chris@40
|
3270 int cw = getColourScaleWidth(paint);
|
Chris@40
|
3271
|
Chris@0
|
3272 int tw = paint.fontMetrics().width(QString("%1")
|
Chris@0
|
3273 .arg(m_maxFrequency > 0 ?
|
Chris@0
|
3274 m_maxFrequency - 1 :
|
Chris@0
|
3275 m_model->getSampleRate() / 2));
|
Chris@0
|
3276
|
Chris@234
|
3277 int fw = paint.fontMetrics().width(tr("43Hz"));
|
Chris@0
|
3278 if (tw < fw) tw = fw;
|
Chris@40
|
3279
|
Chris@40
|
3280 int tickw = (m_frequencyScale == LogFrequencyScale ? 10 : 4);
|
Chris@0
|
3281
|
Chris@40
|
3282 return cw + tickw + tw + 13;
|
Chris@0
|
3283 }
|
Chris@0
|
3284
|
Chris@0
|
3285 void
|
Chris@44
|
3286 SpectrogramLayer::paintVerticalScale(View *v, QPainter &paint, QRect rect) const
|
Chris@0
|
3287 {
|
Chris@0
|
3288 if (!m_model || !m_model->isOK()) {
|
Chris@0
|
3289 return;
|
Chris@0
|
3290 }
|
Chris@0
|
3291
|
Chris@382
|
3292 Profiler profiler("SpectrogramLayer::paintVerticalScale");
|
Chris@122
|
3293
|
Chris@120
|
3294 //!!! cache this?
|
Chris@120
|
3295
|
Chris@0
|
3296 int h = rect.height(), w = rect.width();
|
Chris@0
|
3297
|
Chris@40
|
3298 int tickw = (m_frequencyScale == LogFrequencyScale ? 10 : 4);
|
Chris@40
|
3299 int pkw = (m_frequencyScale == LogFrequencyScale ? 10 : 0);
|
Chris@40
|
3300
|
Chris@107
|
3301 size_t bins = m_fftSize / 2;
|
Chris@0
|
3302 int sr = m_model->getSampleRate();
|
Chris@0
|
3303
|
Chris@0
|
3304 if (m_maxFrequency > 0) {
|
Chris@107
|
3305 bins = int((double(m_maxFrequency) * m_fftSize) / sr + 0.1);
|
Chris@107
|
3306 if (bins > m_fftSize / 2) bins = m_fftSize / 2;
|
Chris@0
|
3307 }
|
Chris@0
|
3308
|
Chris@40
|
3309 int cw = getColourScaleWidth(paint);
|
Chris@119
|
3310 int cbw = paint.fontMetrics().width("dB");
|
Chris@40
|
3311
|
Chris@0
|
3312 int py = -1;
|
Chris@0
|
3313 int textHeight = paint.fontMetrics().height();
|
Chris@0
|
3314 int toff = -textHeight + paint.fontMetrics().ascent() + 2;
|
Chris@0
|
3315
|
Chris@119
|
3316 if (h > textHeight * 3 + 10) {
|
Chris@119
|
3317
|
Chris@119
|
3318 int topLines = 2;
|
Chris@119
|
3319 if (m_colourScale == PhaseColourScale) topLines = 1;
|
Chris@119
|
3320
|
Chris@119
|
3321 int ch = h - textHeight * (topLines + 1) - 8;
|
Chris@119
|
3322 // paint.drawRect(4, textHeight + 4, cw - 1, ch + 1);
|
Chris@119
|
3323 paint.drawRect(4 + cw - cbw, textHeight * topLines + 4, cbw - 1, ch + 1);
|
Chris@40
|
3324
|
Chris@40
|
3325 QString top, bottom;
|
Chris@119
|
3326 float min = m_viewMags[v].getMin();
|
Chris@119
|
3327 float max = m_viewMags[v].getMax();
|
Chris@119
|
3328
|
Chris@119
|
3329 float dBmin = AudioLevel::multiplier_to_dB(min);
|
Chris@119
|
3330 float dBmax = AudioLevel::multiplier_to_dB(max);
|
Chris@119
|
3331
|
Chris@120
|
3332 if (dBmax < -60.f) dBmax = -60.f;
|
Chris@120
|
3333 else top = QString("%1").arg(lrintf(dBmax));
|
Chris@120
|
3334
|
Chris@120
|
3335 if (dBmin < dBmax - 60.f) dBmin = dBmax - 60.f;
|
Chris@119
|
3336 bottom = QString("%1").arg(lrintf(dBmin));
|
Chris@119
|
3337
|
Chris@119
|
3338 //!!! & phase etc
|
Chris@119
|
3339
|
Chris@119
|
3340 if (m_colourScale != PhaseColourScale) {
|
Chris@119
|
3341 paint.drawText((cw + 6 - paint.fontMetrics().width("dBFS")) / 2,
|
Chris@119
|
3342 2 + textHeight + toff, "dBFS");
|
Chris@119
|
3343 }
|
Chris@119
|
3344
|
Chris@119
|
3345 // paint.drawText((cw + 6 - paint.fontMetrics().width(top)) / 2,
|
Chris@119
|
3346 paint.drawText(3 + cw - cbw - paint.fontMetrics().width(top),
|
Chris@119
|
3347 2 + textHeight * topLines + toff + textHeight/2, top);
|
Chris@119
|
3348
|
Chris@119
|
3349 paint.drawText(3 + cw - cbw - paint.fontMetrics().width(bottom),
|
Chris@119
|
3350 h + toff - 3 - textHeight/2, bottom);
|
Chris@40
|
3351
|
Chris@40
|
3352 paint.save();
|
Chris@40
|
3353 paint.setBrush(Qt::NoBrush);
|
Chris@119
|
3354
|
Chris@119
|
3355 int lasty = 0;
|
Chris@119
|
3356 int lastdb = 0;
|
Chris@119
|
3357
|
Chris@40
|
3358 for (int i = 0; i < ch; ++i) {
|
Chris@119
|
3359
|
Chris@119
|
3360 float dBval = dBmin + (((dBmax - dBmin) * i) / (ch - 1));
|
Chris@119
|
3361 int idb = int(dBval);
|
Chris@119
|
3362
|
Chris@119
|
3363 float value = AudioLevel::dB_to_multiplier(dBval);
|
Chris@119
|
3364 int colour = getDisplayValue(v, value * m_gain);
|
Chris@210
|
3365
|
Chris@197
|
3366 paint.setPen(m_palette.getColour(colour));
|
Chris@119
|
3367
|
Chris@119
|
3368 int y = textHeight * topLines + 4 + ch - i;
|
Chris@119
|
3369
|
Chris@119
|
3370 paint.drawLine(5 + cw - cbw, y, cw + 2, y);
|
Chris@119
|
3371
|
Chris@119
|
3372 if (i == 0) {
|
Chris@119
|
3373 lasty = y;
|
Chris@119
|
3374 lastdb = idb;
|
Chris@119
|
3375 } else if (i < ch - paint.fontMetrics().ascent() &&
|
Chris@120
|
3376 idb != lastdb &&
|
Chris@119
|
3377 ((abs(y - lasty) > textHeight &&
|
Chris@119
|
3378 idb % 10 == 0) ||
|
Chris@119
|
3379 (abs(y - lasty) > paint.fontMetrics().ascent() &&
|
Chris@119
|
3380 idb % 5 == 0))) {
|
Chris@287
|
3381 paint.setPen(v->getBackground());
|
Chris@119
|
3382 QString text = QString("%1").arg(idb);
|
Chris@119
|
3383 paint.drawText(3 + cw - cbw - paint.fontMetrics().width(text),
|
Chris@119
|
3384 y + toff + textHeight/2, text);
|
Chris@287
|
3385 paint.setPen(v->getForeground());
|
Chris@119
|
3386 paint.drawLine(5 + cw - cbw, y, 8 + cw - cbw, y);
|
Chris@119
|
3387 lasty = y;
|
Chris@119
|
3388 lastdb = idb;
|
Chris@119
|
3389 }
|
Chris@40
|
3390 }
|
Chris@40
|
3391 paint.restore();
|
Chris@40
|
3392 }
|
Chris@40
|
3393
|
Chris@40
|
3394 paint.drawLine(cw + 7, 0, cw + 7, h);
|
Chris@40
|
3395
|
Chris@0
|
3396 int bin = -1;
|
Chris@0
|
3397
|
Chris@44
|
3398 for (int y = 0; y < v->height(); ++y) {
|
Chris@0
|
3399
|
Chris@0
|
3400 float q0, q1;
|
Chris@44
|
3401 if (!getYBinRange(v, v->height() - y, q0, q1)) continue;
|
Chris@0
|
3402
|
Chris@0
|
3403 int vy;
|
Chris@0
|
3404
|
Chris@0
|
3405 if (int(q0) > bin) {
|
Chris@0
|
3406 vy = y;
|
Chris@0
|
3407 bin = int(q0);
|
Chris@0
|
3408 } else {
|
Chris@0
|
3409 continue;
|
Chris@0
|
3410 }
|
Chris@0
|
3411
|
Chris@107
|
3412 int freq = (sr * bin) / m_fftSize;
|
Chris@0
|
3413
|
Chris@0
|
3414 if (py >= 0 && (vy - py) < textHeight - 1) {
|
Chris@40
|
3415 if (m_frequencyScale == LinearFrequencyScale) {
|
Chris@40
|
3416 paint.drawLine(w - tickw, h - vy, w, h - vy);
|
Chris@40
|
3417 }
|
Chris@0
|
3418 continue;
|
Chris@0
|
3419 }
|
Chris@0
|
3420
|
Chris@0
|
3421 QString text = QString("%1").arg(freq);
|
Chris@234
|
3422 if (bin == 1) text = tr("%1Hz").arg(freq); // bin 0 is DC
|
Chris@40
|
3423 paint.drawLine(cw + 7, h - vy, w - pkw - 1, h - vy);
|
Chris@0
|
3424
|
Chris@0
|
3425 if (h - vy - textHeight >= -2) {
|
Chris@40
|
3426 int tx = w - 3 - paint.fontMetrics().width(text) - std::max(tickw, pkw);
|
Chris@0
|
3427 paint.drawText(tx, h - vy + toff, text);
|
Chris@0
|
3428 }
|
Chris@0
|
3429
|
Chris@0
|
3430 py = vy;
|
Chris@0
|
3431 }
|
Chris@40
|
3432
|
Chris@40
|
3433 if (m_frequencyScale == LogFrequencyScale) {
|
Chris@40
|
3434
|
Chris@277
|
3435 // piano keyboard
|
Chris@277
|
3436
|
Chris@40
|
3437 paint.drawLine(w - pkw - 1, 0, w - pkw - 1, h);
|
Chris@40
|
3438
|
Chris@40
|
3439 float minf = getEffectiveMinFrequency();
|
Chris@40
|
3440 float maxf = getEffectiveMaxFrequency();
|
Chris@40
|
3441
|
Chris@122
|
3442 int py = h, ppy = h;
|
Chris@40
|
3443 paint.setBrush(paint.pen().color());
|
Chris@40
|
3444
|
Chris@40
|
3445 for (int i = 0; i < 128; ++i) {
|
Chris@40
|
3446
|
Chris@40
|
3447 float f = Pitch::getFrequencyForPitch(i);
|
Chris@44
|
3448 int y = lrintf(v->getYForFrequency(f, minf, maxf, true));
|
Chris@122
|
3449
|
Chris@122
|
3450 if (y < -2) break;
|
Chris@122
|
3451 if (y > h + 2) {
|
Chris@122
|
3452 continue;
|
Chris@122
|
3453 }
|
Chris@122
|
3454
|
Chris@40
|
3455 int n = (i % 12);
|
Chris@122
|
3456
|
Chris@122
|
3457 if (n == 1) {
|
Chris@122
|
3458 // C# -- fill the C from here
|
Chris@284
|
3459 QColor col = Qt::gray;
|
Chris@284
|
3460 if (i == 61) { // filling middle C
|
Chris@284
|
3461 col = Qt::blue;
|
Chris@284
|
3462 col = col.light(150);
|
Chris@284
|
3463 }
|
Chris@122
|
3464 if (ppy - y > 2) {
|
Chris@122
|
3465 paint.fillRect(w - pkw,
|
Chris@122
|
3466 y,
|
Chris@122
|
3467 pkw,
|
Chris@122
|
3468 (py + ppy) / 2 - y,
|
Chris@284
|
3469 col);
|
Chris@122
|
3470 }
|
Chris@122
|
3471 }
|
Chris@122
|
3472
|
Chris@40
|
3473 if (n == 1 || n == 3 || n == 6 || n == 8 || n == 10) {
|
Chris@40
|
3474 // black notes
|
Chris@40
|
3475 paint.drawLine(w - pkw, y, w, y);
|
Chris@41
|
3476 int rh = ((py - y) / 4) * 2;
|
Chris@41
|
3477 if (rh < 2) rh = 2;
|
Chris@41
|
3478 paint.drawRect(w - pkw, y - (py-y)/4, pkw/2, rh);
|
Chris@40
|
3479 } else if (n == 0 || n == 5) {
|
Chris@122
|
3480 // C, F
|
Chris@40
|
3481 if (py < h) {
|
Chris@40
|
3482 paint.drawLine(w - pkw, (y + py) / 2, w, (y + py) / 2);
|
Chris@40
|
3483 }
|
Chris@40
|
3484 }
|
Chris@40
|
3485
|
Chris@122
|
3486 ppy = py;
|
Chris@40
|
3487 py = y;
|
Chris@40
|
3488 }
|
Chris@40
|
3489 }
|
Chris@0
|
3490 }
|
Chris@0
|
3491
|
Chris@187
|
3492 class SpectrogramRangeMapper : public RangeMapper
|
Chris@187
|
3493 {
|
Chris@187
|
3494 public:
|
Chris@248
|
3495 SpectrogramRangeMapper(int sr, int /* fftsize */) :
|
Chris@187
|
3496 m_dist(float(sr) / 2),
|
Chris@187
|
3497 m_s2(sqrtf(sqrtf(2))) { }
|
Chris@187
|
3498 ~SpectrogramRangeMapper() { }
|
Chris@187
|
3499
|
Chris@187
|
3500 virtual int getPositionForValue(float value) const {
|
Chris@187
|
3501
|
Chris@187
|
3502 float dist = m_dist;
|
Chris@187
|
3503
|
Chris@187
|
3504 int n = 0;
|
Chris@187
|
3505
|
Chris@187
|
3506 while (dist > (value + 0.00001) && dist > 0.1f) {
|
Chris@187
|
3507 dist /= m_s2;
|
Chris@187
|
3508 ++n;
|
Chris@187
|
3509 }
|
Chris@187
|
3510
|
Chris@187
|
3511 return n;
|
Chris@187
|
3512 }
|
Chris@187
|
3513
|
Chris@187
|
3514 virtual float getValueForPosition(int position) const {
|
Chris@187
|
3515
|
Chris@187
|
3516 // Vertical zoom step 0 shows the entire range from DC ->
|
Chris@187
|
3517 // Nyquist frequency. Step 1 shows 2^(1/4) of the range of
|
Chris@187
|
3518 // step 0, and so on until the visible range is smaller than
|
Chris@187
|
3519 // the frequency step between bins at the current fft size.
|
Chris@187
|
3520
|
Chris@187
|
3521 float dist = m_dist;
|
Chris@187
|
3522
|
Chris@187
|
3523 int n = 0;
|
Chris@187
|
3524 while (n < position) {
|
Chris@187
|
3525 dist /= m_s2;
|
Chris@187
|
3526 ++n;
|
Chris@187
|
3527 }
|
Chris@187
|
3528
|
Chris@187
|
3529 return dist;
|
Chris@187
|
3530 }
|
Chris@187
|
3531
|
Chris@187
|
3532 virtual QString getUnit() const { return "Hz"; }
|
Chris@187
|
3533
|
Chris@187
|
3534 protected:
|
Chris@187
|
3535 float m_dist;
|
Chris@187
|
3536 float m_s2;
|
Chris@187
|
3537 };
|
Chris@187
|
3538
|
Chris@133
|
3539 int
|
Chris@133
|
3540 SpectrogramLayer::getVerticalZoomSteps(int &defaultStep) const
|
Chris@133
|
3541 {
|
Chris@135
|
3542 if (!m_model) return 0;
|
Chris@187
|
3543
|
Chris@187
|
3544 int sr = m_model->getSampleRate();
|
Chris@187
|
3545
|
Chris@187
|
3546 SpectrogramRangeMapper mapper(sr, m_fftSize);
|
Chris@187
|
3547
|
Chris@187
|
3548 // int maxStep = mapper.getPositionForValue((float(sr) / m_fftSize) + 0.001);
|
Chris@187
|
3549 int maxStep = mapper.getPositionForValue(0);
|
Chris@187
|
3550 int minStep = mapper.getPositionForValue(float(sr) / 2);
|
Chris@250
|
3551
|
Chris@250
|
3552 size_t initialMax = m_initialMaxFrequency;
|
Chris@250
|
3553 if (initialMax == 0) initialMax = sr / 2;
|
Chris@250
|
3554
|
Chris@250
|
3555 defaultStep = mapper.getPositionForValue(initialMax) - minStep;
|
Chris@250
|
3556
|
Chris@250
|
3557 // std::cerr << "SpectrogramLayer::getVerticalZoomSteps: " << maxStep - minStep << " (" << maxStep <<"-" << minStep << "), default is " << defaultStep << " (from initial max freq " << initialMax << ")" << std::endl;
|
Chris@187
|
3558
|
Chris@187
|
3559 return maxStep - minStep;
|
Chris@133
|
3560 }
|
Chris@133
|
3561
|
Chris@133
|
3562 int
|
Chris@133
|
3563 SpectrogramLayer::getCurrentVerticalZoomStep() const
|
Chris@133
|
3564 {
|
Chris@133
|
3565 if (!m_model) return 0;
|
Chris@133
|
3566
|
Chris@133
|
3567 float dmin, dmax;
|
Chris@133
|
3568 getDisplayExtents(dmin, dmax);
|
Chris@133
|
3569
|
Chris@187
|
3570 SpectrogramRangeMapper mapper(m_model->getSampleRate(), m_fftSize);
|
Chris@187
|
3571 int n = mapper.getPositionForValue(dmax - dmin);
|
Chris@248
|
3572 // std::cerr << "SpectrogramLayer::getCurrentVerticalZoomStep: " << n << std::endl;
|
Chris@133
|
3573 return n;
|
Chris@133
|
3574 }
|
Chris@133
|
3575
|
Chris@133
|
3576 void
|
Chris@133
|
3577 SpectrogramLayer::setVerticalZoomStep(int step)
|
Chris@133
|
3578 {
|
Chris@187
|
3579 if (!m_model) return;
|
Chris@187
|
3580
|
Chris@253
|
3581 float dmin = m_minFrequency, dmax = m_maxFrequency;
|
Chris@253
|
3582 // getDisplayExtents(dmin, dmax);
|
Chris@253
|
3583
|
Chris@253
|
3584 // std::cerr << "current range " << dmin << " -> " << dmax << ", range " << dmax-dmin << ", mid " << (dmax + dmin)/2 << std::endl;
|
Chris@133
|
3585
|
Chris@133
|
3586 int sr = m_model->getSampleRate();
|
Chris@187
|
3587 SpectrogramRangeMapper mapper(sr, m_fftSize);
|
Chris@253
|
3588 float newdist = mapper.getValueForPosition(step);
|
Chris@253
|
3589
|
Chris@253
|
3590 float newmin, newmax;
|
Chris@253
|
3591
|
Chris@253
|
3592 if (m_frequencyScale == LogFrequencyScale) {
|
Chris@253
|
3593
|
Chris@253
|
3594 // need to pick newmin and newmax such that
|
Chris@253
|
3595 //
|
Chris@253
|
3596 // (log(newmin) + log(newmax)) / 2 == logmid
|
Chris@253
|
3597 // and
|
Chris@253
|
3598 // newmax - newmin = newdist
|
Chris@253
|
3599 //
|
Chris@253
|
3600 // so log(newmax - newdist) + log(newmax) == 2logmid
|
Chris@253
|
3601 // log(newmax(newmax - newdist)) == 2logmid
|
Chris@253
|
3602 // newmax.newmax - newmax.newdist == exp(2logmid)
|
Chris@253
|
3603 // newmax^2 + (-newdist)newmax + -exp(2logmid) == 0
|
Chris@253
|
3604 // quadratic with a = 1, b = -newdist, c = -exp(2logmid), all known
|
Chris@253
|
3605 //
|
Chris@253
|
3606 // positive root
|
Chris@253
|
3607 // newmax = (newdist + sqrt(newdist^2 + 4exp(2logmid))) / 2
|
Chris@253
|
3608 //
|
Chris@253
|
3609 // but logmid = (log(dmin) + log(dmax)) / 2
|
Chris@253
|
3610 // so exp(2logmid) = exp(log(dmin) + log(dmax))
|
Chris@253
|
3611 // = exp(log(dmin.dmax))
|
Chris@253
|
3612 // = dmin.dmax
|
Chris@253
|
3613 // so newmax = (newdist + sqrtf(newdist^2 + 4dmin.dmax)) / 2
|
Chris@253
|
3614
|
Chris@253
|
3615 newmax = (newdist + sqrtf(newdist*newdist + 4*dmin*dmax)) / 2;
|
Chris@253
|
3616 newmin = newmax - newdist;
|
Chris@253
|
3617
|
Chris@253
|
3618 // std::cerr << "newmin = " << newmin << ", newmax = " << newmax << std::endl;
|
Chris@253
|
3619
|
Chris@253
|
3620 } else {
|
Chris@253
|
3621 float dmid = (dmax + dmin) / 2;
|
Chris@253
|
3622 newmin = dmid - newdist / 2;
|
Chris@253
|
3623 newmax = dmid + newdist / 2;
|
Chris@253
|
3624 }
|
Chris@187
|
3625
|
Chris@187
|
3626 float mmin, mmax;
|
Chris@187
|
3627 mmin = 0;
|
Chris@187
|
3628 mmax = float(sr) / 2;
|
Chris@133
|
3629
|
Chris@187
|
3630 if (newmin < mmin) {
|
Chris@187
|
3631 newmax += (mmin - newmin);
|
Chris@187
|
3632 newmin = mmin;
|
Chris@187
|
3633 }
|
Chris@187
|
3634 if (newmax > mmax) {
|
Chris@187
|
3635 newmax = mmax;
|
Chris@187
|
3636 }
|
Chris@133
|
3637
|
Chris@253
|
3638 // std::cerr << "SpectrogramLayer::setVerticalZoomStep: " << step << ": " << newmin << " -> " << newmax << " (range " << newdist << ")" << std::endl;
|
Chris@253
|
3639
|
Chris@253
|
3640 setMinFrequency(lrintf(newmin));
|
Chris@253
|
3641 setMaxFrequency(lrintf(newmax));
|
Chris@187
|
3642 }
|
Chris@187
|
3643
|
Chris@187
|
3644 RangeMapper *
|
Chris@187
|
3645 SpectrogramLayer::getNewVerticalZoomRangeMapper() const
|
Chris@187
|
3646 {
|
Chris@187
|
3647 if (!m_model) return 0;
|
Chris@187
|
3648 return new SpectrogramRangeMapper(m_model->getSampleRate(), m_fftSize);
|
Chris@133
|
3649 }
|
Chris@133
|
3650
|
Chris@273
|
3651 void
|
Chris@273
|
3652 SpectrogramLayer::updateMeasureRectYCoords(View *v, const MeasureRect &r) const
|
Chris@273
|
3653 {
|
Chris@273
|
3654 int y0 = 0;
|
Chris@273
|
3655 if (r.startY > 0.0) y0 = getYForFrequency(v, r.startY);
|
Chris@273
|
3656
|
Chris@273
|
3657 int y1 = y0;
|
Chris@273
|
3658 if (r.endY > 0.0) y1 = getYForFrequency(v, r.endY);
|
Chris@273
|
3659
|
Chris@273
|
3660 // std::cerr << "SpectrogramLayer::updateMeasureRectYCoords: start " << r.startY << " -> " << y0 << ", end " << r.endY << " -> " << y1 << std::endl;
|
Chris@273
|
3661
|
Chris@273
|
3662 r.pixrect = QRect(r.pixrect.x(), y0, r.pixrect.width(), y1 - y0);
|
Chris@273
|
3663 }
|
Chris@273
|
3664
|
Chris@273
|
3665 void
|
Chris@273
|
3666 SpectrogramLayer::setMeasureRectYCoord(View *v, MeasureRect &r, bool start, int y) const
|
Chris@273
|
3667 {
|
Chris@273
|
3668 if (start) {
|
Chris@273
|
3669 r.startY = getFrequencyForY(v, y);
|
Chris@273
|
3670 r.endY = r.startY;
|
Chris@273
|
3671 } else {
|
Chris@273
|
3672 r.endY = getFrequencyForY(v, y);
|
Chris@273
|
3673 }
|
Chris@273
|
3674 // std::cerr << "SpectrogramLayer::setMeasureRectYCoord: start " << r.startY << " <- " << y << ", end " << r.endY << " <- " << y << std::endl;
|
Chris@273
|
3675
|
Chris@273
|
3676 }
|
Chris@273
|
3677
|
Chris@316
|
3678 void
|
Chris@316
|
3679 SpectrogramLayer::toXml(QTextStream &stream,
|
Chris@316
|
3680 QString indent, QString extraAttributes) const
|
Chris@6
|
3681 {
|
Chris@6
|
3682 QString s;
|
Chris@6
|
3683
|
Chris@6
|
3684 s += QString("channel=\"%1\" "
|
Chris@6
|
3685 "windowSize=\"%2\" "
|
Chris@153
|
3686 "windowHopLevel=\"%3\" "
|
Chris@153
|
3687 "gain=\"%4\" "
|
Chris@153
|
3688 "threshold=\"%5\" ")
|
Chris@6
|
3689 .arg(m_channel)
|
Chris@6
|
3690 .arg(m_windowSize)
|
Chris@97
|
3691 .arg(m_windowHopLevel)
|
Chris@37
|
3692 .arg(m_gain)
|
Chris@37
|
3693 .arg(m_threshold);
|
Chris@37
|
3694
|
Chris@37
|
3695 s += QString("minFrequency=\"%1\" "
|
Chris@37
|
3696 "maxFrequency=\"%2\" "
|
Chris@37
|
3697 "colourScale=\"%3\" "
|
Chris@37
|
3698 "colourScheme=\"%4\" "
|
Chris@37
|
3699 "colourRotation=\"%5\" "
|
Chris@37
|
3700 "frequencyScale=\"%6\" "
|
Chris@37
|
3701 "binDisplay=\"%7\" "
|
Chris@153
|
3702 "normalizeColumns=\"%8\" "
|
Chris@153
|
3703 "normalizeVisibleArea=\"%9\"")
|
Chris@37
|
3704 .arg(m_minFrequency)
|
Chris@6
|
3705 .arg(m_maxFrequency)
|
Chris@6
|
3706 .arg(m_colourScale)
|
Chris@197
|
3707 .arg(m_colourMap)
|
Chris@37
|
3708 .arg(m_colourRotation)
|
Chris@35
|
3709 .arg(m_frequencyScale)
|
Chris@37
|
3710 .arg(m_binDisplay)
|
Chris@153
|
3711 .arg(m_normalizeColumns ? "true" : "false")
|
Chris@153
|
3712 .arg(m_normalizeVisibleArea ? "true" : "false");
|
Chris@6
|
3713
|
Chris@316
|
3714 Layer::toXml(stream, indent, extraAttributes + " " + s);
|
Chris@6
|
3715 }
|
Chris@6
|
3716
|
Chris@11
|
3717 void
|
Chris@11
|
3718 SpectrogramLayer::setProperties(const QXmlAttributes &attributes)
|
Chris@11
|
3719 {
|
Chris@11
|
3720 bool ok = false;
|
Chris@11
|
3721
|
Chris@11
|
3722 int channel = attributes.value("channel").toInt(&ok);
|
Chris@11
|
3723 if (ok) setChannel(channel);
|
Chris@11
|
3724
|
Chris@11
|
3725 size_t windowSize = attributes.value("windowSize").toUInt(&ok);
|
Chris@11
|
3726 if (ok) setWindowSize(windowSize);
|
Chris@11
|
3727
|
Chris@97
|
3728 size_t windowHopLevel = attributes.value("windowHopLevel").toUInt(&ok);
|
Chris@97
|
3729 if (ok) setWindowHopLevel(windowHopLevel);
|
Chris@97
|
3730 else {
|
Chris@97
|
3731 size_t windowOverlap = attributes.value("windowOverlap").toUInt(&ok);
|
Chris@97
|
3732 // a percentage value
|
Chris@97
|
3733 if (ok) {
|
Chris@97
|
3734 if (windowOverlap == 0) setWindowHopLevel(0);
|
Chris@97
|
3735 else if (windowOverlap == 25) setWindowHopLevel(1);
|
Chris@97
|
3736 else if (windowOverlap == 50) setWindowHopLevel(2);
|
Chris@97
|
3737 else if (windowOverlap == 75) setWindowHopLevel(3);
|
Chris@97
|
3738 else if (windowOverlap == 90) setWindowHopLevel(4);
|
Chris@97
|
3739 }
|
Chris@97
|
3740 }
|
Chris@11
|
3741
|
Chris@11
|
3742 float gain = attributes.value("gain").toFloat(&ok);
|
Chris@11
|
3743 if (ok) setGain(gain);
|
Chris@11
|
3744
|
Chris@37
|
3745 float threshold = attributes.value("threshold").toFloat(&ok);
|
Chris@37
|
3746 if (ok) setThreshold(threshold);
|
Chris@37
|
3747
|
Chris@37
|
3748 size_t minFrequency = attributes.value("minFrequency").toUInt(&ok);
|
Chris@187
|
3749 if (ok) {
|
Chris@187
|
3750 std::cerr << "SpectrogramLayer::setProperties: setting min freq to " << minFrequency << std::endl;
|
Chris@187
|
3751 setMinFrequency(minFrequency);
|
Chris@187
|
3752 }
|
Chris@37
|
3753
|
Chris@11
|
3754 size_t maxFrequency = attributes.value("maxFrequency").toUInt(&ok);
|
Chris@187
|
3755 if (ok) {
|
Chris@187
|
3756 std::cerr << "SpectrogramLayer::setProperties: setting max freq to " << maxFrequency << std::endl;
|
Chris@187
|
3757 setMaxFrequency(maxFrequency);
|
Chris@187
|
3758 }
|
Chris@11
|
3759
|
Chris@11
|
3760 ColourScale colourScale = (ColourScale)
|
Chris@11
|
3761 attributes.value("colourScale").toInt(&ok);
|
Chris@11
|
3762 if (ok) setColourScale(colourScale);
|
Chris@11
|
3763
|
Chris@197
|
3764 int colourMap = attributes.value("colourScheme").toInt(&ok);
|
Chris@197
|
3765 if (ok) setColourMap(colourMap);
|
Chris@11
|
3766
|
Chris@37
|
3767 int colourRotation = attributes.value("colourRotation").toInt(&ok);
|
Chris@37
|
3768 if (ok) setColourRotation(colourRotation);
|
Chris@37
|
3769
|
Chris@11
|
3770 FrequencyScale frequencyScale = (FrequencyScale)
|
Chris@11
|
3771 attributes.value("frequencyScale").toInt(&ok);
|
Chris@11
|
3772 if (ok) setFrequencyScale(frequencyScale);
|
Chris@35
|
3773
|
Chris@37
|
3774 BinDisplay binDisplay = (BinDisplay)
|
Chris@37
|
3775 attributes.value("binDisplay").toInt(&ok);
|
Chris@37
|
3776 if (ok) setBinDisplay(binDisplay);
|
Chris@36
|
3777
|
Chris@36
|
3778 bool normalizeColumns =
|
Chris@36
|
3779 (attributes.value("normalizeColumns").trimmed() == "true");
|
Chris@36
|
3780 setNormalizeColumns(normalizeColumns);
|
Chris@153
|
3781
|
Chris@153
|
3782 bool normalizeVisibleArea =
|
Chris@153
|
3783 (attributes.value("normalizeVisibleArea").trimmed() == "true");
|
Chris@153
|
3784 setNormalizeVisibleArea(normalizeVisibleArea);
|
Chris@11
|
3785 }
|
Chris@11
|
3786
|