annotate layer/SpectrogramLayer.cpp @ 130:10eec0da9efe last-cc-copyright

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