annotate layer/SpectrogramLayer.cpp @ 58:01ab51f72e84

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