annotate layer/SpectrogramLayer.cpp @ 486:c860cab85904

* Finer locking in fft caches; fix displayed bin ranges in spectrogram
author Chris Cannam
date Thu, 05 Feb 2009 12:05:28 +0000
parents 3f9fddc890e0
children 6a5327c0a40f
rev   line source
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