libs/canvas/wave_view.cc

   1 /*
   2     Copyright (C) 2011-2013 Paul Davis
   3     Author: Carl Hetherington <cth@carlh.net>
   4
   5     This program is free software; you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation; either version 2 of the License, or
   8     (at your option) any later version.
   9
  10     This program is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU General Public License for more details.
  14
  15     You should have received a copy of the GNU General Public License
  16     along with this program; if not, write to the Free Software
  17     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18
  19 */
  20
  21 #include <cmath>
  22 #include <cairomm/cairomm.h>
  23
  24 #include "gtkmm2ext/utils.h"
  25
  26 #include "pbd/compose.h"
  27 #include "pbd/signals.h"
  28
  29 #include "ardour/types.h"
  30 #include "ardour/dB.h"
  31 #include "ardour/audioregion.h"
  32
  33 #include "canvas/wave_view.h"
  34 #include "canvas/utils.h"
  35 #include "canvas/canvas.h"
  36
  37 #include <gdkmm/general.h>
  38
  39 using namespace std;
  40 using namespace ARDOUR;
  41 using namespace ArdourCanvas;
  42
  43 double WaveView::_global_gradient_depth = 0.6;
  44 bool WaveView::_global_logscaled = false;
  45 WaveView::Shape WaveView::_global_shape = WaveView::Normal;
  46
  47 PBD::Signal0<void> WaveView::VisualPropertiesChanged;
  48
  49 WaveView::WaveView (Group* parent, boost::shared_ptr<ARDOUR::AudioRegion> region)
  50         : Item (parent)
  51         , Outline (parent)
  52         , Fill (parent)
  53         , _region (region)
  54         , _channel (0)
  55         , _samples_per_pixel (0)
  56         , _height (64)
  57         , _wave_color (0xffffffff)
  58         , _show_zero (true)
  59         , _zero_color (0xff0000ff)
  60         , _clip_color (0xff0000ff)
  61         , _logscaled (_global_logscaled)
  62         , _shape (_global_shape)
  63         , _gradient_depth (_global_gradient_depth)
  64         , _shape_independent (false)
  65         , _logscaled_independent (false)
  66         , _gradient_depth_independent (false)
  67         , _amplitude_above_axis (1.0)
  68         , _region_start (0)
  69 {
  70         VisualPropertiesChanged.connect_same_thread (invalidation_connection, boost::bind (&WaveView::handle_visual_property_change, this));
  71 }
  72
  73 void
  74 WaveView::handle_visual_property_change ()
  75 {
  76         bool changed = false;
  77
  78         if (!_shape_independent && (_shape != global_shape())) {
  79                 _shape = global_shape();
  80                 changed = true;
  81         }
  82
  83         if (!_logscaled_independent && (_logscaled != global_logscaled())) {
  84                 _logscaled = global_logscaled();
  85                 changed = true;
  86         }
  87
  88         if (!_gradient_depth_independent && (_gradient_depth != global_gradient_depth())) {
  89                 _gradient_depth = global_gradient_depth();
  90                 changed = true;
  91         }
  92
  93         if (changed) {
  94                 invalidate_image_cache ();
  95         }
  96 }
  97
  98 void
  99 WaveView::set_fill_color (Color c)
 100 {
 101         invalidate_image_cache ();
 102         Fill::set_fill_color (c);
 103 }
 104
 105 void
 106 WaveView::set_outline_color (Color c)
 107 {
 108         invalidate_image_cache ();
 109         Outline::set_outline_color (c);
 110 }
 111
 112 void
 113 WaveView::set_samples_per_pixel (double samples_per_pixel)
 114 {
 115         begin_change ();
 116
 117         _samples_per_pixel = samples_per_pixel;
 118
 119         _bounding_box_dirty = true;
 120         end_change ();
 121
 122         invalidate_whole_cache ();
 123 }
 124
 125 void
 126 WaveView::render (Rect const & area, Cairo::RefPtr<Cairo::Context> context) const
 127 {
 128         assert (_samples_per_pixel != 0);
 129
 130         if (!_region) {
 131                 return;
 132         }
 133
 134         /* p, start and end are offsets from the start of the source.
 135            area is relative to the position of the region.
 136          */
 137
 138         int const start = rint (area.x0 + _region_start / _samples_per_pixel);
 139         int const end   = rint (area.x1 + _region_start / _samples_per_pixel);
 140
 141         int p = start;
 142         list<CacheEntry*>::iterator cache = _cache.begin ();
 143
 144         while (p < end) {
 145
 146                 /* Step through cache entries that end at or before our current position, p */
 147                 while (cache != _cache.end() && (*cache)->end() <= p) {
 148                         ++cache;
 149                 }
 150
 151                 /* Now either:
 152                    1. we have run out of cache entries
 153                    2. the one we are looking at finishes after p but also starts after p.
 154                    3. the one we are looking at finishes after p and starts before p.
 155
 156                    Set up a pointer to the cache entry that we will use on this iteration.
 157                 */
 158
 159                 CacheEntry* render = 0;
 160
 161                 if (cache == _cache.end ()) {
 162
 163                         /* Case 1: we have run out of cache entries, so make a new one for
 164                            the whole required area and put it in the list.
 165                         */
 166
 167                         CacheEntry* c = new CacheEntry (this, p, end);
 168                         _cache.push_back (c);
 169                         render = c;
 170
 171                 } else if ((*cache)->start() > p) {
 172
 173                         /* Case 2: we have a cache entry, but it starts after p, so we
 174                            need another one for the missing bit.
 175                         */
 176
 177                         CacheEntry* c = new CacheEntry (this, p, min (end, (*cache)->start()));
 178                         cache = _cache.insert (cache, c);
 179                         ++cache;
 180                         render = c;
 181
 182                 } else {
 183
 184                         /* Case 3: we have a cache entry that will do at least some of what
 185                            we have left, so render it.
 186                         */
 187
 188                         render = *cache;
 189                         ++cache;
 190
 191                 }
 192
 193                 int const this_end = min (end, render->end ());
 194
 195                 Coord const left  =        p - _region_start / _samples_per_pixel;
 196                 Coord const right = this_end - _region_start / _samples_per_pixel;
 197
 198                 context->save ();
 199
 200                 context->rectangle (left, area.y0, right, area.height());
 201                 context->clip ();
 202
 203                 context->translate (left, 0);
 204
 205                 context->set_source (render->image(), render->start() - p, 0);
 206                 context->paint ();
 207
 208                 context->restore ();
 209
 210                 p = min (end, render->end ());
 211         }
 212 }
 213
 214 void
 215 WaveView::compute_bounding_box () const
 216 {
 217         if (_region) {
 218                 _bounding_box = Rect (0, 0, _region->length() / _samples_per_pixel, _height);
 219         } else {
 220                 _bounding_box = boost::optional<Rect> ();
 221         }
 222
 223         _bounding_box_dirty = false;
 224 }
 225
 226 void
 227 WaveView::set_height (Distance height)
 228 {
 229         begin_change ();
 230
 231         _height = height;
 232
 233         _bounding_box_dirty = true;
 234         end_change ();
 235
 236         invalidate_image_cache ();
 237 }
 238
 239 void
 240 WaveView::set_channel (int channel)
 241 {
 242         begin_change ();
 243
 244         _channel = channel;
 245
 246         _bounding_box_dirty = true;
 247         end_change ();
 248
 249         invalidate_whole_cache ();
 250 }
 251
 252 void
 253 WaveView::invalidate_whole_cache ()
 254 {
 255         begin_visual_change ();
 256         for (list<CacheEntry*>::iterator i = _cache.begin(); i != _cache.end(); ++i) {
 257                 delete *i;
 258         }
 259
 260         _cache.clear ();
 261
 262         end_visual_change ();
 263 }
 264
 265 void
 266 WaveView::invalidate_image_cache ()
 267 {
 268         begin_visual_change ();
 269
 270         for (list<CacheEntry*>::iterator i = _cache.begin(); i != _cache.end(); ++i) {
 271                 (*i)->clear_image ();
 272         }
 273
 274         end_visual_change ();
 275 }
 276
 277 void
 278 WaveView::region_resized ()
 279 {
 280         _bounding_box_dirty = true;
 281 }
 282
 283 void
 284 WaveView::set_logscaled (bool yn)
 285 {
 286         if (_logscaled != yn) {
 287                 _logscaled = yn;
 288                 invalidate_image_cache ();
 289         }
 290 }
 291
 292 void
 293 WaveView::gain_changed ()
 294 {
 295         invalidate_whole_cache ();
 296 }
 297
 298 void
 299 WaveView::set_zero_color (Color c)
 300 {
 301         if (_zero_color != c) {
 302                 _zero_color = c;
 303                 invalidate_image_cache ();
 304         }
 305 }
 306
 307 void
 308 WaveView::set_clip_color (Color c)
 309 {
 310         if (_clip_color != c) {
 311                 _clip_color = c;
 312                 invalidate_image_cache ();
 313         }
 314 }
 315
 316 void
 317 WaveView::set_show_zero_line (bool yn)
 318 {
 319         if (_show_zero != yn) {
 320                 _show_zero = yn;
 321                 invalidate_image_cache ();
 322         }
 323 }
 324
 325 void
 326 WaveView::set_shape (Shape s)
 327 {
 328         if (_shape != s) {
 329                 _shape = s;
 330                 invalidate_image_cache ();
 331         }
 332 }
 333
 334 void
 335 WaveView::set_amplitude_above_axis (double a)
 336 {
 337         if (_amplitude_above_axis != a) {
 338                 _amplitude_above_axis = a;
 339                 invalidate_image_cache ();
 340         }
 341 }
 342
 343 void
 344 WaveView::set_global_shape (Shape s)
 345 {
 346         if (_global_shape != s) {
 347                 _global_shape = s;
 348                 VisualPropertiesChanged (); /* EMIT SIGNAL */
 349         }
 350 }
 351
 352 void
 353 WaveView::set_global_logscaled (bool yn)
 354 {
 355         if (_global_logscaled != yn) {
 356                 _global_logscaled = yn;
 357                 VisualPropertiesChanged (); /* EMIT SIGNAL */
 358
 359         }
 360 }
 361
 362 void
 363 WaveView::set_region_start (frameoffset_t start)
 364 {
 365         _region_start = start;
 366         _bounding_box_dirty = true;
 367 }
 368
 369 /** Construct a new CacheEntry with peak data between two offsets
 370  *  in the source.
 371  */
 372 WaveView::CacheEntry::CacheEntry (WaveView const * wave_view, int start, int end)
 373         : _wave_view (wave_view)
 374         , _start (start)
 375         , _end (end)
 376 {
 377         _n_peaks = _end - _start;
 378         _peaks.reset (new PeakData[_n_peaks]);
 379
 380         _wave_view->_region->read_peaks (
 381                 _peaks.get(),
 382                 _n_peaks,
 383                 _start * _wave_view->_samples_per_pixel,
 384                 (_end - _start) * _wave_view->_samples_per_pixel,
 385                 _wave_view->_channel,
 386                 _wave_view->_samples_per_pixel
 387                 );
 388 }
 389
 390 WaveView::CacheEntry::~CacheEntry ()
 391 {
 392 }
 393
 394 static inline float
 395 _log_meter (float power, double lower_db, double upper_db, double non_linearity)
 396 {
 397         return (power < lower_db ? 0.0 : pow((power-lower_db)/(upper_db-lower_db), non_linearity));
 398 }
 399
 400 static inline float
 401 alt_log_meter (float power)
 402 {
 403         return _log_meter (power, -192.0, 0.0, 8.0);
 404 }
 405
 406 Cairo::RefPtr<Cairo::ImageSurface>
 407 WaveView::CacheEntry::image ()
 408 {
 409         if (!_image) {
 410
 411                 _image = Cairo::ImageSurface::create (Cairo::FORMAT_ARGB32, _n_peaks, _wave_view->_height);
 412                 Cairo::RefPtr<Cairo::Context> context = Cairo::Context::create (_image);
 413
 414                 /* Draw the edge of the waveform, top half first, the loop back
 415                  * for the bottom half to create a clockwise path
 416                  */
 417
 418                 context->begin_new_path();
 419
 420                 if (_wave_view->_shape == WaveView::Rectified) {
 421
 422                         /* top edge of waveform is based on max (fabs (peak_min, peak_max))
 423                          */
 424
 425                         if (_wave_view->_logscaled) {
 426                                 for (int i = 0; i < _n_peaks; ++i) {
 427                                         context->line_to (i + 0.5, position (alt_log_meter (fast_coefficient_to_dB (
 428                                                                                                     max (fabs (_peaks[i].max), fabs (_peaks[i].min))))));
 429                                 }
 430                         } else {
 431                                 for (int i = 0; i < _n_peaks; ++i) {
 432                                         context->line_to (i + 0.5, position (max (fabs (_peaks[i].max), fabs (_peaks[i].min))));
 433                                 }
 434                         }
 435
 436                 } else {
 437                         if (_wave_view->_logscaled) {
 438                                 for (int i = 0; i < _n_peaks; ++i) {
 439                                         Coord y = _peaks[i].max;
 440                                         if (y > 0.0) {
 441                                                 context->line_to (i + 0.5, position (alt_log_meter (fast_coefficient_to_dB (y))));
 442                                         } else if (y < 0.0) {
 443                                                 context->line_to (i + 0.5, position (-alt_log_meter (fast_coefficient_to_dB (-y))));
 444                                         } else {
 445                                                 context->line_to (i + 0.5, position (0.0));
 446                                         }
 447                                 }
 448                         } else {
 449                                 for (int i = 0; i < _n_peaks; ++i) {
 450                                         context->line_to (i + 0.5, position (_peaks[i].max));
 451                                 }
 452                         }
 453                 }
 454
 455                 /* from final top point, move out of the clip zone */
 456
 457                 context->line_to (_n_peaks + 10, position (0.0));
 458
 459
 460                 /* bottom half, in reverse */
 461
 462                 if (_wave_view->_shape == WaveView::Rectified) {
 463
 464                         /* lower half: drop to the bottom, then a line back to
 465                          * beyond the left edge of the clip region
 466                          */
 467
 468                         context->line_to (_n_peaks + 10, _wave_view->_height);
 469                         context->line_to (-10.0, _wave_view->_height);
 470
 471                 } else {
 472
 473                         if (_wave_view->_logscaled) {
 474                                 for (int i = _n_peaks-1; i >= 0; --i) {
 475                                         Coord y = _peaks[i].min;
 476                                         if (y > 0.0) {
 477                                                 context->line_to (i + 0.5, position (alt_log_meter (fast_coefficient_to_dB (y))));
 478                                         } else if (y < 0.0) {
 479                                                 context->line_to (i + 0.5, position (-alt_log_meter (fast_coefficient_to_dB (-y))));
 480                                         } else {
 481                                                 context->line_to (i + 0.5, position (0.0));
 482                                         }
 483                                 }
 484                         } else {
 485                                 for (int i = _n_peaks-1; i >= 0; --i) {
 486                                         context->line_to (i + 0.5, position (_peaks[i].min));
 487                                 }
 488                         }
 489
 490                         /* from final bottom point, move out of the clip zone */
 491
 492                         context->line_to (-10.0, position (0.0));
 493                 }
 494
 495                 context->close_path ();
 496
 497                 if (_wave_view->gradient_depth() != 0.0) {
 498
 499                         Cairo::RefPtr<Cairo::LinearGradient> gradient (Cairo::LinearGradient::create (0, 0, 0, _wave_view->_height));
 500
 501                         double stops[3];
 502
 503                         double r, g, b, a;
 504
 505                         if (_wave_view->_shape == Rectified) {
 506                                 stops[0] = 0.1;
 507                                 stops[0] = 0.3;
 508                                 stops[0] = 0.9;
 509                         } else {
 510                                 stops[0] = 0.1;
 511                                 stops[1] = 0.5;
 512                                 stops[2] = 0.9;
 513                         }
 514
 515                         color_to_rgba (_wave_view->_fill_color, r, g, b, a);
 516                         gradient->add_color_stop_rgba (stops[0], r, g, b, a);
 517                         gradient->add_color_stop_rgba (stops[2], r, g, b, a);
 518
 519                         /* generate a new color for the middle of the gradient */
 520                         double h, s, v;
 521                         color_to_hsv (_wave_view->_fill_color, h, s, v);
 522                         /* tone down the saturation */
 523                         s *= 1.0 - _wave_view->gradient_depth();
 524                         Color center = hsv_to_color (h, s, v, a);
 525                         color_to_rgba (center, r, g, b, a);
 526                         gradient->add_color_stop_rgba (stops[1], r, g, b, a);
 527
 528                         context->set_source (gradient);
 529                 } else {
 530                         set_source_rgba (context, _wave_view->_fill_color);
 531                 }
 532
 533                 context->fill_preserve ();
 534                 _wave_view->setup_outline_context (context);
 535                 context->stroke ();
 536
 537                 if (_wave_view->show_zero_line()) {
 538                         set_source_rgba (context, _wave_view->_zero_color);
 539                         context->move_to (0, position (0.0));
 540                         context->line_to (_n_peaks, position (0.0));
 541                         context->stroke ();
 542                 }
 543         }
 544
 545         return _image;
 546 }
 547
 548
 549 Coord
 550 WaveView::CacheEntry::position (double s) const
 551 {
 552         switch (_wave_view->_shape) {
 553         case Rectified:
 554                 return _wave_view->_height - (s * _wave_view->_height);
 555         default:
 556                 break;
 557         }
 558         return (1.0-s) * (_wave_view->_height / 2.0);
 559 }
 560
 561 void
 562 WaveView::CacheEntry::clear_image ()
 563 {
 564         _image.clear ();
 565 }
 566
 567 void
 568 WaveView::set_global_gradient_depth (double depth)
 569 {
 570         if (_global_gradient_depth != depth) {
 571                 _global_gradient_depth = depth;
 572                 VisualPropertiesChanged (); /* EMIT SIGNAL */
 573         }
 574 }