ardour
canvas-waveview.c
Go to the documentation of this file.
1 /*
2  Copyright (C) 2000-2002 Paul Davis
3 
4  This program is free software; you can redistribute it and/or modify
5  it under the terms of the GNU General Public License as published by
6  the Free Software Foundation; either version 2 of the License, or
7  (at your option) any later version.
8 
9  This program is distributed in the hope that it will be useful,
10  but WITHOUT ANY WARRANTY; without even the implied warranty of
11  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12  GNU General Public License for more details.
13 
14  You should have received a copy of the GNU General Public License
15  along with this program; if not, write to the Free Software
16  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
17 
18  $Id$
19 */
20 
21 #include <stdio.h>
22 #include <math.h>
23 #include <libgnomecanvas/libgnomecanvas.h>
24 #include <cairo.h>
25 #include <string.h>
26 #include <limits.h>
27 #include <unistd.h>
28 
29 #include "ardour/dB.h"
30 
31 #include "logmeter.h"
32 #include "canvas-waveview.h"
33 #include "rgb_macros.h"
34 
35 /* POSIX guarantees casting between void* and function pointers, ISO C doesn't
36  * We can work around warnings by going one step deeper in our casts
37  */
38 #if defined(_POSIX_VERSION) || defined(COMPILER_MINGW)
39 #define POSIX_FUNC_PTR_CAST(type, object) *((type*) &(object))
40 #endif // _POSIX_VERSION
41 
42 extern void c_stacktrace(void);
43 
44 enum {
45  PROP_0,
46  PROP_DATA_SRC,
47  PROP_CHANNEL,
48  PROP_LENGTH_FUNCTION,
49  PROP_SOURCEFILE_LENGTH_FUNCTION,
50  PROP_PEAK_FUNCTION,
51  PROP_GAIN_FUNCTION,
52  PROP_GAIN_SRC,
53  PROP_CACHE,
54  PROP_CACHE_UPDATER,
55  PROP_SAMPLES_PER_UNIT,
56  PROP_AMPLITUDE_ABOVE_AXIS,
57  PROP_X,
58  PROP_Y,
59  PROP_HEIGHT,
60  PROP_WAVE_COLOR,
61  PROP_CLIP_COLOR,
62  PROP_ZERO_COLOR,
63  PROP_FILL_COLOR,
64  PROP_FILLED,
65  PROP_RECTIFIED,
66  PROP_ZERO_LINE,
67  PROP_REGION_START,
68  PROP_LOGSCALED,
69 };
70 
71 static void gnome_canvas_waveview_class_init (GnomeCanvasWaveViewClass *class);
72 
73 static void gnome_canvas_waveview_init (GnomeCanvasWaveView *waveview);
74 
75 static void gnome_canvas_waveview_destroy (GtkObject *object);
76 
77 static void gnome_canvas_waveview_set_property (GObject *object,
78  guint prop_id,
79  const GValue *value,
80  GParamSpec *pspec);
81 static void gnome_canvas_waveview_get_property (GObject *object,
82  guint prop_id,
83  GValue *value,
84  GParamSpec *pspec);
85 
86 static void gnome_canvas_waveview_update (GnomeCanvasItem *item,
87  double *affine,
88  ArtSVP *clip_path,
89  int flags);
90 
91 static void gnome_canvas_waveview_bounds (GnomeCanvasItem *item,
92  double *x1,
93  double *y1,
94  double *x2,
95  double *y2);
96 
97 static double gnome_canvas_waveview_point (GnomeCanvasItem *item,
98  double x,
99  double y,
100  int cx,
101  int cy,
102  GnomeCanvasItem **actual_item);
103 
104 static void gnome_canvas_waveview_render (GnomeCanvasItem *item,
105  GnomeCanvasBuf *buf);
106 
107 static void gnome_canvas_waveview_draw (GnomeCanvasItem *item,
108  GdkDrawable *drawable,
109  int x,
110  int y,
111  int w,
112  int h);
113 
114 static void gnome_canvas_waveview_set_data_src (GnomeCanvasWaveView *,
115  void *);
116 
117 static void gnome_canvas_waveview_set_channel (GnomeCanvasWaveView *,
118  guint32);
119 
120 static guint32 gnome_canvas_waveview_ensure_cache (GnomeCanvasWaveView *waveview,
121  gulong start_sample,
122  gulong end_sample);
123 
124 
125 static int _gradient_rendering = 0;
126 
127 static GnomeCanvasItemClass *parent_class;
128 
129 GType
130 gnome_canvas_waveview_get_type (void)
131 {
132  static GType waveview_type;
133 
134  if (!waveview_type) {
135  static const GTypeInfo object_info = {
136  sizeof (GnomeCanvasWaveViewClass),
137  (GBaseInitFunc) NULL,
138  (GBaseFinalizeFunc) NULL,
139  (GClassInitFunc) gnome_canvas_waveview_class_init,
140  (GClassFinalizeFunc) NULL,
141  NULL, /* class_data */
142  sizeof (GnomeCanvasWaveView),
143  0, /* n_preallocs */
144  (GInstanceInitFunc) gnome_canvas_waveview_init,
145  NULL /* value_table */
146  };
147 
148  waveview_type = g_type_register_static (GNOME_TYPE_CANVAS_ITEM, "GnomeCanvasWaveView",
149  &object_info, 0);
150  }
151 
152  return waveview_type;
153  }
154 
155 static void
156 gnome_canvas_waveview_class_init (GnomeCanvasWaveViewClass *class)
157 {
158  GObjectClass *gobject_class;
159  GtkObjectClass *object_class;
160  GnomeCanvasItemClass *item_class;
161 
162  gobject_class = (GObjectClass *) class;
163  object_class = (GtkObjectClass *) class;
164  item_class = (GnomeCanvasItemClass *) class;
165 
166  parent_class = g_type_class_peek_parent (class);
167 
168  gobject_class->set_property = gnome_canvas_waveview_set_property;
169  gobject_class->get_property = gnome_canvas_waveview_get_property;
170 
171  g_object_class_install_property
172  (gobject_class,
173  PROP_DATA_SRC,
174  g_param_spec_pointer ("data_src", NULL, NULL,
175  (G_PARAM_READABLE | G_PARAM_WRITABLE)));
176 
177  g_object_class_install_property
178  (gobject_class,
179  PROP_CHANNEL,
180  g_param_spec_uint ("channel", NULL, NULL,
181  0, G_MAXUINT, 0,
182  (G_PARAM_READABLE | G_PARAM_WRITABLE)));
183 
184  g_object_class_install_property
185  (gobject_class,
186  PROP_LENGTH_FUNCTION,
187  g_param_spec_pointer ("length_function", NULL, NULL,
188  (G_PARAM_READABLE | G_PARAM_WRITABLE)));
189 
190  g_object_class_install_property
191  (gobject_class,
192  PROP_SOURCEFILE_LENGTH_FUNCTION,
193  g_param_spec_pointer ("sourcefile_length_function", NULL, NULL,
194  (G_PARAM_READABLE | G_PARAM_WRITABLE)));
195 
196  g_object_class_install_property
197  (gobject_class,
198  PROP_PEAK_FUNCTION,
199  g_param_spec_pointer ("peak_function", NULL, NULL,
200  (G_PARAM_READABLE | G_PARAM_WRITABLE)));
201 
202  g_object_class_install_property
203  (gobject_class,
204  PROP_GAIN_FUNCTION,
205  g_param_spec_pointer ("gain_function", NULL, NULL,
206  (G_PARAM_READABLE | G_PARAM_WRITABLE)));
207 
208  g_object_class_install_property
209  (gobject_class,
210  PROP_GAIN_SRC,
211  g_param_spec_pointer ("gain_src", NULL, NULL,
212  (G_PARAM_READABLE | G_PARAM_WRITABLE)));
213 
214  g_object_class_install_property
215  (gobject_class,
216  PROP_CACHE,
217  g_param_spec_pointer ("cache", NULL, NULL,
218  (G_PARAM_READABLE | G_PARAM_WRITABLE)));
219 
220  g_object_class_install_property
221  (gobject_class,
222  PROP_CACHE_UPDATER,
223  g_param_spec_boolean ("cache_updater", NULL, NULL,
224  FALSE,
225  (G_PARAM_READABLE | G_PARAM_WRITABLE)));
226 
227  g_object_class_install_property
228  (gobject_class,
229  PROP_SAMPLES_PER_UNIT,
230  g_param_spec_double ("samples_per_unit", NULL, NULL,
231  0.0, G_MAXDOUBLE, 0.0,
232  (G_PARAM_READABLE | G_PARAM_WRITABLE)));
233 
234  g_object_class_install_property
235  (gobject_class,
236  PROP_AMPLITUDE_ABOVE_AXIS,
237  g_param_spec_double ("amplitude_above_axis", NULL, NULL,
238  0.0, G_MAXDOUBLE, 0.0,
239  (G_PARAM_READABLE | G_PARAM_WRITABLE)));
240 
241  g_object_class_install_property
242  (gobject_class,
243  PROP_X,
244  g_param_spec_double ("x", NULL, NULL,
245  0.0, G_MAXDOUBLE, 0.0,
246  (G_PARAM_READABLE | G_PARAM_WRITABLE)));
247 
248  g_object_class_install_property
249  (gobject_class,
250  PROP_Y,
251  g_param_spec_double ("y", NULL, NULL,
252  0.0, G_MAXDOUBLE, 0.0,
253  (G_PARAM_READABLE | G_PARAM_WRITABLE)));
254 
255  g_object_class_install_property
256  (gobject_class,
257  PROP_HEIGHT,
258  g_param_spec_double ("height", NULL, NULL,
259  0.0, G_MAXDOUBLE, 0.0,
260  (G_PARAM_READABLE | G_PARAM_WRITABLE)));
261 
262  g_object_class_install_property
263  (gobject_class,
264  PROP_WAVE_COLOR,
265  g_param_spec_uint ("wave_color", NULL, NULL,
266  0, G_MAXUINT, 0,
267  (G_PARAM_READABLE | G_PARAM_WRITABLE)));
268 
269  g_object_class_install_property
270  (gobject_class,
271  PROP_CLIP_COLOR,
272  g_param_spec_uint ("clip_color", NULL, NULL,
273  0, G_MAXUINT, 0,
274  (G_PARAM_READABLE | G_PARAM_WRITABLE)));
275 
276  g_object_class_install_property
277  (gobject_class,
278  PROP_ZERO_COLOR,
279  g_param_spec_uint ("zero_color", NULL, NULL,
280  0, G_MAXUINT, 0,
281  (G_PARAM_READABLE | G_PARAM_WRITABLE)));
282 
283  g_object_class_install_property
284  (gobject_class,
285  PROP_FILL_COLOR,
286  g_param_spec_uint ("fill_color", NULL, NULL,
287  0, G_MAXUINT, 0,
288  (G_PARAM_READABLE | G_PARAM_WRITABLE)));
289 
290  g_object_class_install_property
291  (gobject_class,
292  PROP_FILLED,
293  g_param_spec_boolean ("filled", NULL, NULL,
294  FALSE,
295  (G_PARAM_READABLE | G_PARAM_WRITABLE)));
296 
297  g_object_class_install_property
298  (gobject_class,
299  PROP_RECTIFIED,
300  g_param_spec_boolean ("rectified", NULL, NULL,
301  FALSE,
302  (G_PARAM_READABLE | G_PARAM_WRITABLE)));
303 
304  g_object_class_install_property
305  (gobject_class,
306  PROP_ZERO_LINE,
307  g_param_spec_boolean ("zero_line", NULL, NULL,
308  FALSE,
309  (G_PARAM_READABLE | G_PARAM_WRITABLE)));
310 
311  g_object_class_install_property
312  (gobject_class,
313  PROP_LOGSCALED,
314  g_param_spec_boolean ("logscaled", NULL, NULL,
315  FALSE,
316  (G_PARAM_READABLE | G_PARAM_WRITABLE)));
317 
318  g_object_class_install_property
319  (gobject_class,
320  PROP_REGION_START,
321  g_param_spec_uint ("region_start", NULL, NULL,
322  0, G_MAXUINT, 0,
323  (G_PARAM_READABLE | G_PARAM_WRITABLE)));
324 
325  object_class->destroy = gnome_canvas_waveview_destroy;
326 
327  item_class->update = gnome_canvas_waveview_update;
328  item_class->bounds = gnome_canvas_waveview_bounds;
329  item_class->point = gnome_canvas_waveview_point;
330  item_class->render = gnome_canvas_waveview_render;
331  item_class->draw = gnome_canvas_waveview_draw;
332 }
333 
334 void
335 gnome_canvas_waveview_set_gradient_waveforms (int yn)
336 {
337  _gradient_rendering = yn;
338 }
339 
340 GnomeCanvasWaveViewCache*
341 gnome_canvas_waveview_cache_new (void)
342 {
343  GnomeCanvasWaveViewCache *c;
344 
345  c = g_malloc (sizeof (GnomeCanvasWaveViewCache));
346 
347  c->allocated = 2048;
348  c->data = g_malloc (sizeof (GnomeCanvasWaveViewCacheEntry) * c->allocated);
349  c->data_size = 0;
350  c->start = 0;
351  c->end = 0;
352 
353  return c;
354 }
355 
356 void
357 gnome_canvas_waveview_cache_destroy (GnomeCanvasWaveViewCache* cache)
358 {
359  g_free (cache->data);
360  g_free (cache);
361 }
362 
363 static void
364 gnome_canvas_waveview_init (GnomeCanvasWaveView *waveview)
365 {
366  waveview->x = 0.0;
367  waveview->y = 0.0;
368  waveview->cache = 0;
369  waveview->cache_updater = FALSE;
370  waveview->data_src = NULL;
371  waveview->channel = 0;
372  waveview->peak_function = NULL;
373  waveview->length_function = NULL;
374  waveview->sourcefile_length_function = NULL;
375  waveview->gain_curve_function = NULL;
376  waveview->gain_src = NULL;
377  waveview->rectified = FALSE;
378  waveview->logscaled = FALSE;
379  waveview->filled = TRUE;
380  waveview->zero_line = FALSE;
381  waveview->region_start = 0;
382  waveview->samples_per_unit = 1.0;
383  waveview->amplitude_above_axis = 1.0;
384  waveview->height = 100.0;
385  waveview->screen_width = gdk_screen_width ();
386  waveview->reload_cache_in_render = FALSE;
387 
388  waveview->wave_color = 0;
389  waveview->clip_color = 0;
390  waveview->zero_color = 0;
391  waveview->fill_color = 0;
392 }
393 
394 static void
395 gnome_canvas_waveview_destroy (GtkObject *object)
396 {
397  g_return_if_fail (object != NULL);
398  g_return_if_fail (GNOME_IS_CANVAS_WAVEVIEW (object));
399 
400  if (GTK_OBJECT_CLASS (parent_class)->destroy)
401  (* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
402 }
403 
404 #define DEBUG_CACHE 0
405 #undef CACHE_MEMMOVE_OPTIMIZATION
406 
408 static guint32
409 gnome_canvas_waveview_ensure_cache (GnomeCanvasWaveView *waveview, gulong start_sample, gulong end_sample)
410 {
411  gulong required_cache_entries;
412  gulong rf1, rf2,rf3, required_frames;
413  gulong new_cache_start, new_cache_end;
414  gulong half_width;
415  gulong npeaks;
416  gulong offset;
417  gulong ostart;
418  gulong copied;
419  GnomeCanvasWaveViewCache *cache;
420  float* gain;
421 #ifdef CACHE_MEMMOVE_OPTIMIZATION
422  gulong present_frames;
423  gulong present_entries;
424 #endif
425 
426  cache = waveview->cache;
427 
428  start_sample = start_sample + waveview->region_start;
429  end_sample = end_sample + waveview->region_start;
430 #if DEBUG_CACHE
431  // printf("waveview->region_start == %lu\n",waveview->region_start);
432  // c_stacktrace ();
433  printf ("\n\n=> 0x%x cache @ 0x%x range: %lu - %lu request: %lu - %lu (%lu frames)\n",
434  waveview, cache,
435  cache->start, cache->end,
436  start_sample, end_sample, end_sample - start_sample);
437 #endif
438 
439  if (cache->start <= start_sample && cache->end >= end_sample) {
440 #if DEBUG_CACHE
441  // printf ("0x%x: cache hit for %lu-%lu (cache holds: %lu-%lu\n",
442  // waveview, start_sample, end_sample, cache->start, cache->end);
443 #endif
444  goto out;
445  }
446 
447  /* make sure the cache is at least twice as wide as the screen width, and put the start sample
448  in the middle, ensuring that we cover the end_sample.
449  */
450 
451  /* Note the assumption that we have a 1:1 units:pixel ratio for the canvas. Its everywhere ... */
452 
453  half_width = (gulong) floor ((waveview->screen_width * waveview->samples_per_unit)/2.0 + 0.5);
454 
455  if (start_sample < half_width) {
456  new_cache_start = 0;
457  } else {
458  new_cache_start = start_sample - half_width;
459  }
460 
461  /* figure out how many frames we want */
462 
463  rf1 = end_sample - start_sample + 1;
464  rf2 = (gulong) floor ((waveview->screen_width * waveview->samples_per_unit * 2.0f));
465  required_frames = MAX(rf1,rf2);
466 
467  /* but make sure it doesn't extend beyond the end of the source material */
468 
469  rf3 = (gulong) (waveview->sourcefile_length_function (waveview->data_src, waveview->samples_per_unit)) + 1;
470  if (rf3 < new_cache_start) {
471  rf3 = 0;
472  } else {
473  rf3 -= new_cache_start;
474  }
475 
476 #if DEBUG_CACHE
477  fprintf (stderr, "AVAILABLE FRAMES = %lu of %lu, start = %lu, sstart = %lu, cstart = %lu\n",
478  rf3, waveview->sourcefile_length_function (waveview->data_src, waveview->samples_per_unit),
479  waveview->region_start, start_sample, new_cache_start);
480 #endif
481 
482  required_frames = MIN(required_frames,rf3);
483 
484  new_cache_end = new_cache_start + required_frames - 1;
485 
486  required_cache_entries = (gulong) floor (required_frames / waveview->samples_per_unit );
487 
488 #if DEBUG_CACHE
489  fprintf (stderr, "new cache = %lu - %lu\n", new_cache_start, new_cache_end);
490  fprintf(stderr,"required_cach_entries = %lu, samples_per_unit = %f req frames = %lu\n",
491  required_cache_entries,waveview->samples_per_unit, required_frames);
492 #endif
493 
494  if (required_cache_entries > cache->allocated) {
495  cache->data = g_realloc (cache->data, sizeof (GnomeCanvasWaveViewCacheEntry) * required_cache_entries);
496  cache->allocated = required_cache_entries;
497  // cache->start = 0;
498  // cache->end = 0;
499  }
500 
501  ostart = new_cache_start;
502 
503 #ifdef CACHE_MEMMOVE_OPTIMIZATION
504 
505  /* data is not entirely in the cache, so go fetch it, making sure to fill the cache */
506 
507  /* some of the required cache entries are in the cache, but in the wrong
508  locations. use memmove to fix this.
509  */
510 
511  if (cache->start < new_cache_start && new_cache_start < cache->end) {
512 
513  /* case one: the common area is at the end of the existing cache. move it
514  to the beginning of the cache, and set up to refill whatever remains.
515 
516 
517  wv->cache_start wv->cache_end
518  |-------------------------------------------------------| cache
519  |--------------------------------| requested
520  <------------------->
521  "present"
522  new_cache_start new_cache_end
523  */
524 
525 
526  present_frames = cache->end - new_cache_start;
527  present_entries = (gulong) floor (present_frames / waveview->samples_per_unit);
528 
529 #if DEBUG_CACHE
530  fprintf (stderr, "existing material at end of current cache, move to start of new cache\n"
531  "\tcopy from %lu to start\n", cache->data_size - present_entries);
532 #endif
533 
534  memmove (&cache->data[0],
535  &cache->data[cache->data_size - present_entries],
536  present_entries * sizeof (GnomeCanvasWaveViewCacheEntry));
537 
538 #if DEBUG_CACHE
539  fprintf (stderr, "satisfied %lu of %lu frames, offset = %lu, will start at %lu (ptr = 0x%x)\n",
540  present_frames, required_frames, present_entries, new_cache_start + present_entries,
541  cache->data + present_entries);
542 #endif
543 
544  copied = present_entries;
545  offset = present_entries;
546  new_cache_start += present_frames;
547  required_frames -= present_frames;
548 
549  } else if (new_cache_end > cache->start && new_cache_end < cache->end) {
550 
551  /* case two: the common area lives at the beginning of the existing cache.
552 
553  wv->cache_start wv->cache_end
554  |-----------------------------------------------------|
555  |--------------------------------|
556  <----------------->
557  "present"
558 
559  new_cache_start new_cache_end
560  */
561 
562  present_frames = new_cache_end - cache->start;
563  present_entries = (gulong) floor (present_frames / waveview->samples_per_unit);
564 
565  memmove (&cache->data[cache->data_size - present_entries],
566  &cache->data[0],
567  present_entries * sizeof (GnomeCanvasWaveViewCacheEntry));
568 
569 #if DEBUG_CACHE
570  fprintf (stderr, "existing material at start of current cache, move to start of end cache\n");
571 #endif
572 
573 #if DEBUG_CACHE
574  fprintf (stderr, "satisfied %lu of %lu frames, offset = %lu, will start at %lu (ptr = 0x%x)\n",
575  present_entries, required_frames, present_entries, new_cache_start + present_entries,
576  cache->data + present_entries);
577 #endif
578 
579  copied = present_entries;
580  offset = 0;
581  required_frames -= present_frames;
582 
583 
584  } else {
585  copied = 0;
586  offset = 0;
587 
588  }
589 
590 #else
591  copied = 0;
592  offset = 0;
593 
594 #endif /* CACHE_MEMMOVE_OPTIMIZATION */
595 
596 // fprintf(stderr,"length == %lu\n",waveview->length_function (waveview->data_src));
597 // required_frames = MIN (waveview->length_function (waveview->data_src) - new_cache_start, required_frames);
598 
599  npeaks = (gulong) floor (required_frames / waveview->samples_per_unit);
600  required_frames = npeaks * waveview->samples_per_unit;
601 
602 #if DEBUG_CACHE
603 
604 
605  printf ("requesting %lu/%f to cover %lu-%lu at %f spu (request was %lu-%lu) into cache + %lu\n",
606  required_frames, required_frames/waveview->samples_per_unit, new_cache_start, new_cache_end,
607  waveview->samples_per_unit, start_sample, end_sample, offset);
608 #endif
609 
610 #if DEBUG_CACHE
611 // printf ("cache holds %lu entries, requesting %lu to cover %lu-%lu (request was %lu-%lu)\n",
612 // cache->data_size, npeaks, new_cache_start, new_cache_end,
613 // start_sample, end_sample);
614 #endif
615 
616  if (required_frames) {
617  waveview->peak_function (waveview->data_src, npeaks, new_cache_start, required_frames, cache->data + offset, waveview->channel,waveview->samples_per_unit);
618 
619  /* take into account any copied peaks */
620 
621  npeaks += copied;
622  } else {
623  npeaks = copied;
624  }
625 
626  if (npeaks < cache->allocated) {
627 #if DEBUG_CACHE
628  fprintf (stderr, "zero fill cache for %lu at %lu\n", cache->allocated - npeaks, npeaks);
629 #endif
630  memset (&cache->data[npeaks], 0, sizeof (GnomeCanvasWaveViewCacheEntry) * (cache->allocated - npeaks));
631  cache->data_size = npeaks;
632  } else {
633  cache->data_size = cache->allocated;
634  }
635 
636  if (waveview->gain_curve_function) {
637  guint32 n;
638 
639  gain = (float*) malloc (sizeof (float) * cache->data_size);
640 
641  waveview->gain_curve_function (waveview->gain_src, new_cache_start, new_cache_end, gain, cache->data_size);
642 
643  for (n = 0; n < cache->data_size; ++n) {
644  cache->data[n].min *= gain[n];
645  cache->data[n].max *= gain[n];
646  }
647 
648  free (gain);
649 
650  }
651 
652  /* do optional log scaling. this implementation is not particularly efficient */
653 
654  if (waveview->logscaled) {
655  guint32 n;
656  GnomeCanvasWaveViewCacheEntry* buf = cache->data;
657 
658  for (n = 0; n < cache->data_size; ++n) {
659 
660  if (buf[n].max > 0.0f) {
661  buf[n].max = alt_log_meter(fast_coefficient_to_dB(buf[n].max));
662  } else if (buf[n].max < 0.0f) {
663  buf[n].max = -alt_log_meter(fast_coefficient_to_dB(-buf[n].max));
664  }
665 
666  if (buf[n].min > 0.0f) {
667  buf[n].min = alt_log_meter(fast_coefficient_to_dB(buf[n].min));
668  } else if (buf[n].min < 0.0f) {
669  buf[n].min = -alt_log_meter(fast_coefficient_to_dB(-buf[n].min));
670  }
671  }
672  }
673 
674  cache->start = ostart;
675  cache->end = new_cache_end;
676 
677  out:
678 #if DEBUG_CACHE
679  fprintf (stderr, "return cache index = %d\n",
680  (guint32) floor ((((double) (start_sample - cache->start)) / waveview->samples_per_unit) + 0.5));
681 #endif
682  return (guint32) floor ((((double) (start_sample - cache->start)) / waveview->samples_per_unit) + 0.5);
683 
684 }
685 
686 void
687 gnome_canvas_waveview_set_data_src (GnomeCanvasWaveView *waveview, void *data_src)
688 {
689 
690  if (waveview->cache_updater) {
691  if (waveview->data_src == data_src) {
692  waveview->reload_cache_in_render = TRUE;
693  return;
694  }
695 
696  waveview->cache->start = 0;
697  waveview->cache->end = 0;
698  }
699 
700  waveview->data_src = data_src;
701 }
702 
703 void
704 gnome_canvas_waveview_set_channel (GnomeCanvasWaveView *waveview, guint32 chan)
705 {
706  if (waveview->channel == chan) {
707  return;
708  }
709 
710  waveview->channel = chan;
711 }
712 
713 static void
714 gnome_canvas_waveview_reset_bounds (GnomeCanvasItem *item)
715 
716 {
717  double x1, x2, y1, y2;
718  ArtPoint i1, i2;
719  ArtPoint w1, w2;
720  int Ix1, Ix2, Iy1, Iy2;
721  double i2w[6];
722 
723  gnome_canvas_waveview_bounds (item, &x1, &y1, &x2, &y2);
724 
725  i1.x = x1;
726  i1.y = y1;
727  i2.x = x2;
728  i2.y = y2;
729 
730  gnome_canvas_item_i2w_affine (item, i2w);
731  art_affine_point (&w1, &i1, i2w);
732  art_affine_point (&w2, &i2, i2w);
733 
734  Ix1 = (int) rint(w1.x);
735  Ix2 = (int) rint(w2.x);
736  Iy1 = (int) rint(w1.y);
737  Iy2 = (int) rint(w2.y);
738 
739  gnome_canvas_update_bbox (item, Ix1, Iy1, Ix2, Iy2);
740 }
741 
742 /*
743  * CANVAS CALLBACKS
744  */
745 
746 static void
747 gnome_canvas_waveview_set_property (GObject *object,
748  guint prop_id,
749  const GValue *value,
750  GParamSpec *pspec)
751 
752 {
753  (void) pspec;
754 
755  GnomeCanvasItem *item;
756  GnomeCanvasWaveView *waveview;
757  int redraw = FALSE;
758  int calc_bounds = FALSE;
759 
760  g_return_if_fail (object != NULL);
761  g_return_if_fail (GNOME_IS_CANVAS_WAVEVIEW (object));
762 
763  item = GNOME_CANVAS_ITEM (object);
764  waveview = GNOME_CANVAS_WAVEVIEW (object);
765 
766  void * ptr;
767  switch (prop_id) {
768  case PROP_DATA_SRC:
769  gnome_canvas_waveview_set_data_src (waveview, g_value_get_pointer(value));
770  redraw = TRUE;
771  break;
772 
773  case PROP_CHANNEL:
774  gnome_canvas_waveview_set_channel (waveview, g_value_get_uint(value));
775  redraw = TRUE;
776  break;
777 
778  case PROP_LENGTH_FUNCTION:
779  ptr = g_value_get_pointer(value);
780  waveview->length_function = POSIX_FUNC_PTR_CAST(waveview_length_function_t, ptr);
781  redraw = TRUE;
782  break;
783 
784  case PROP_SOURCEFILE_LENGTH_FUNCTION:
785  ptr = g_value_get_pointer(value);
786  waveview->sourcefile_length_function = POSIX_FUNC_PTR_CAST(waveview_sourcefile_length_function_t, ptr);
787  redraw = TRUE;
788  break;
789 
790  case PROP_PEAK_FUNCTION:
791  ptr = g_value_get_pointer(value);
792  waveview->peak_function = POSIX_FUNC_PTR_CAST(waveview_peak_function_t, ptr);
793  redraw = TRUE;
794  break;
795 
796  case PROP_GAIN_FUNCTION:
797  ptr = g_value_get_pointer(value);
798  waveview->gain_curve_function = POSIX_FUNC_PTR_CAST(waveview_gain_curve_function_t, ptr);
799  redraw = TRUE;
800  break;
801 
802  case PROP_GAIN_SRC:
803  waveview->gain_src = g_value_get_pointer(value);
804  if (waveview->cache_updater) {
805  waveview->cache->start = 0;
806  waveview->cache->end = 0;
807  }
808  redraw = TRUE;
809  calc_bounds = TRUE;
810  break;
811 
812  case PROP_CACHE:
813  waveview->cache = g_value_get_pointer(value);
814  redraw = TRUE;
815  break;
816 
817 
818  case PROP_CACHE_UPDATER:
819  waveview->cache_updater = g_value_get_boolean(value);
820  redraw = TRUE;
821  break;
822 
823  case PROP_SAMPLES_PER_UNIT:
824  if ((waveview->samples_per_unit = g_value_get_double(value)) < 1.0) {
825  waveview->samples_per_unit = 1.0;
826  }
827  if (waveview->cache_updater) {
828  waveview->cache->start = 0;
829  waveview->cache->end = 0;
830  }
831  redraw = TRUE;
832  calc_bounds = TRUE;
833  break;
834 
835  case PROP_AMPLITUDE_ABOVE_AXIS:
836  waveview->amplitude_above_axis = g_value_get_double(value);
837  redraw = TRUE;
838  break;
839 
840  case PROP_X:
841  if (waveview->x != g_value_get_double (value)) {
842  waveview->x = g_value_get_double (value);
843  calc_bounds = TRUE;
844  }
845  break;
846 
847  case PROP_Y:
848  if (waveview->y != g_value_get_double (value)) {
849  waveview->y = g_value_get_double (value);
850  calc_bounds = TRUE;
851  }
852  break;
853 
854  case PROP_HEIGHT:
855  if (waveview->height != fabs (g_value_get_double (value))) {
856  waveview->height = fabs (g_value_get_double (value));
857  redraw = TRUE;
858  }
859  break;
860 
861  case PROP_WAVE_COLOR:
862  if (waveview->wave_color != g_value_get_uint(value)) {
863  waveview->wave_color = g_value_get_uint(value);
864  redraw = TRUE;
865  }
866  break;
867 
868  case PROP_CLIP_COLOR:
869  if (waveview->clip_color != g_value_get_uint(value)) {
870  waveview->clip_color = g_value_get_uint(value);
871  redraw = TRUE;
872  }
873  break;
874 
875  case PROP_ZERO_COLOR:
876  if (waveview->zero_color != g_value_get_uint(value)) {
877  waveview->zero_color = g_value_get_uint(value);
878  redraw = TRUE;
879  }
880  break;
881 
882  case PROP_FILL_COLOR:
883  if (waveview->fill_color != g_value_get_uint(value)) {
884  waveview->fill_color = g_value_get_uint(value);
885  redraw = TRUE;
886  }
887  break;
888 
889  case PROP_FILLED:
890  if (waveview->filled != g_value_get_boolean(value)) {
891  waveview->filled = g_value_get_boolean(value);
892  redraw = TRUE;
893  }
894  break;
895 
896  case PROP_RECTIFIED:
897  if (waveview->rectified != g_value_get_boolean(value)) {
898  waveview->rectified = g_value_get_boolean(value);
899  redraw = TRUE;
900  }
901  break;
902 
903  case PROP_ZERO_LINE:
904  if (waveview->zero_line != g_value_get_boolean(value)) {
905  waveview->zero_line = g_value_get_boolean(value);
906  redraw = TRUE;
907  }
908  break;
909 
910  case PROP_LOGSCALED:
911  if (waveview->logscaled != g_value_get_boolean(value)) {
912  waveview->logscaled = g_value_get_boolean(value);
913  if (waveview->cache_updater) {
914  waveview->cache->start = 0;
915  waveview->cache->end = 0;
916  }
917  redraw = TRUE;
918  calc_bounds = TRUE;
919  }
920  break;
921  case PROP_REGION_START:
922  waveview->region_start = g_value_get_uint(value);
923  redraw = TRUE;
924  calc_bounds = TRUE;
925  break;
926 
927 
928  default:
929  break;
930  }
931 
932  if (calc_bounds) {
933  gnome_canvas_waveview_reset_bounds (item);
934  }
935 
936  if (redraw) {
937  gnome_canvas_item_request_update (item);
938  }
939 
940 }
941 
942 static void
943 gnome_canvas_waveview_get_property (
944  GObject *object,
945  guint prop_id,
946  GValue *value,
947  GParamSpec *pspec)
948 {
949 
950 
951  g_return_if_fail (object != NULL);
952  g_return_if_fail (GNOME_IS_CANVAS_WAVEVIEW (object));
953 
954  GnomeCanvasWaveView *waveview = GNOME_CANVAS_WAVEVIEW (object);
955 
956  switch (prop_id) {
957  case PROP_DATA_SRC:
958  g_value_set_pointer(value, waveview->data_src);
959  break;
960 
961  case PROP_CHANNEL:
962  g_value_set_uint(value, waveview->channel);
963  break;
964 
965  case PROP_LENGTH_FUNCTION:
966  g_value_set_pointer(value, POSIX_FUNC_PTR_CAST(void*, waveview->length_function));
967  break;
968 
969  case PROP_SOURCEFILE_LENGTH_FUNCTION:
970  g_value_set_pointer(value, POSIX_FUNC_PTR_CAST(void*, waveview->sourcefile_length_function));
971  break;
972 
973  case PROP_PEAK_FUNCTION:
974  g_value_set_pointer(value, POSIX_FUNC_PTR_CAST(void*, waveview->peak_function));
975  break;
976 
977  case PROP_GAIN_FUNCTION:
978  g_value_set_pointer(value, POSIX_FUNC_PTR_CAST(void*, waveview->gain_curve_function));
979  break;
980 
981  case PROP_GAIN_SRC:
982  g_value_set_pointer(value, waveview->gain_src);
983  break;
984 
985  case PROP_CACHE:
986  g_value_set_pointer(value, waveview->cache);
987  break;
988 
989  case PROP_CACHE_UPDATER:
990  g_value_set_boolean(value, waveview->cache_updater);
991  break;
992 
993  case PROP_SAMPLES_PER_UNIT:
994  g_value_set_double(value, waveview->samples_per_unit);
995  break;
996 
997  case PROP_AMPLITUDE_ABOVE_AXIS:
998  g_value_set_double(value, waveview->amplitude_above_axis);
999  break;
1000 
1001  case PROP_X:
1002  g_value_set_double (value, waveview->x);
1003  break;
1004 
1005  case PROP_Y:
1006  g_value_set_double (value, waveview->y);
1007  break;
1008 
1009  case PROP_HEIGHT:
1010  g_value_set_double (value, waveview->height);
1011  break;
1012 
1013  case PROP_WAVE_COLOR:
1014  g_value_set_uint (value, waveview->wave_color);
1015  break;
1016 
1017  case PROP_CLIP_COLOR:
1018  g_value_set_uint (value, waveview->clip_color);
1019  break;
1020 
1021  case PROP_ZERO_COLOR:
1022  g_value_set_uint (value, waveview->zero_color);
1023  break;
1024 
1025  case PROP_FILL_COLOR:
1026  g_value_set_uint (value, waveview->fill_color);
1027  break;
1028 
1029  case PROP_FILLED:
1030  g_value_set_boolean (value, waveview->filled);
1031  break;
1032 
1033  case PROP_RECTIFIED:
1034  g_value_set_boolean (value, waveview->rectified);
1035  break;
1036 
1037  case PROP_ZERO_LINE:
1038  g_value_set_boolean (value, waveview->zero_line);
1039  break;
1040 
1041  case PROP_LOGSCALED:
1042  g_value_set_boolean (value, waveview->logscaled);
1043  break;
1044 
1045  case PROP_REGION_START:
1046  g_value_set_uint (value, waveview->region_start);
1047  break;
1048 
1049  default:
1050  G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1051  break;
1052  }
1053 }
1054 
1055 static void
1056 gnome_canvas_waveview_update (GnomeCanvasItem *item, double *affine, ArtSVP *clip_path, int flags)
1057 {
1058  GnomeCanvasWaveView *waveview;
1059  double x, y;
1060 
1061  waveview = GNOME_CANVAS_WAVEVIEW (item);
1062 
1063 // check_cache (waveview, "start of update");
1064 
1065  if (parent_class->update)
1066  (* parent_class->update) (item, affine, clip_path, flags);
1067 
1068  gnome_canvas_waveview_reset_bounds (item);
1069 
1070  /* get the canvas coordinates of the view. Do NOT use affines
1071  for this, because they do not round to the integer units used
1072  by the canvas, resulting in subtle pixel-level errors later.
1073  */
1074 
1075  x = waveview->x;
1076  y = waveview->y;
1077 
1078  gnome_canvas_item_i2w (item, &x, &y);
1079  gnome_canvas_w2c (GNOME_CANVAS(item->canvas), x, y, &waveview->bbox_ulx, &waveview->bbox_uly);
1080 
1081  waveview->samples = waveview->length_function (waveview->data_src);
1082 
1083  x = waveview->x + (waveview->samples / waveview->samples_per_unit);
1084  y = waveview->y + waveview->height;
1085 
1086  gnome_canvas_item_i2w (item, &x, &y);
1087  gnome_canvas_w2c (GNOME_CANVAS(item->canvas), x, y, &waveview->bbox_lrx, &waveview->bbox_lry);
1088 
1089  /* cache the half-height and the end point in canvas units */
1090 
1091  waveview->half_height = waveview->height / 2.0;
1092 
1093  /* parse the color */
1094 
1095  UINT_TO_RGBA (waveview->wave_color, &waveview->wave_r, &waveview->wave_g, &waveview->wave_b,
1096  &waveview->wave_a);
1097  UINT_TO_RGBA (waveview->clip_color, &waveview->clip_r, &waveview->clip_g, &waveview->clip_b,
1098  &waveview->clip_a);
1099  UINT_TO_RGBA (waveview->fill_color, &waveview->fill_r, &waveview->fill_g, &waveview->fill_b,
1100  &waveview->fill_a);
1101 
1102 // check_cache (waveview, "end of update");
1103 }
1104 
1105 static void
1106 gnome_canvas_waveview_gradient_render (GnomeCanvasItem *item,
1107  GnomeCanvasBuf *buf)
1108 {
1109  GnomeCanvasWaveView *waveview;
1110  gulong s1, s2;
1111  int clip_length = 0;
1112  int pymin, pymax;
1113  guint cache_index;
1114  double half_height;
1115  int x;
1116  char rectify;
1117 
1118  waveview = GNOME_CANVAS_WAVEVIEW (item);
1119 
1120 // check_cache (waveview, "start of render");
1121 
1122  if (parent_class->render) {
1123  (*parent_class->render) (item, buf);
1124  }
1125 
1126  if (buf->is_bg) {
1127  gnome_canvas_buf_ensure_buf (buf);
1128  buf->is_bg = FALSE;
1129  }
1130 
1131  /* a "unit" means a pixel */
1132 
1133  /* begin: render start x (units) */
1134  int const begin = MAX (waveview->bbox_ulx, buf->rect.x0);
1135 
1136  /* zbegin: start x for zero line (units) */
1137  int const zbegin = (begin == waveview->bbox_ulx) ? (begin + 1) : begin;
1138 
1139  /* end: render end x (units) */
1140  int const end = (waveview->bbox_lrx >= 0) ? MIN (waveview->bbox_lrx,buf->rect.x1) : buf->rect.x1;
1141 
1142  /* zend: end x for zero-line (units) */
1143  int const zend = (end == waveview->bbox_lrx) ? (end - 1) : end;
1144 
1145  if (begin == end) {
1146  return;
1147  }
1148 
1149  /* s1: start sample
1150  s2: end sample
1151  */
1152 
1153  s1 = floor ((begin - waveview->bbox_ulx) * waveview->samples_per_unit);
1154 
1155  // fprintf (stderr, "0x%x begins at sample %f\n", waveview, waveview->bbox_ulx * waveview->samples_per_unit);
1156 
1157  if (end == waveview->bbox_lrx) {
1158  /* This avoids minor rounding errors when we have the
1159  entire region visible.
1160  */
1161  s2 = waveview->samples;
1162  } else {
1163  s2 = s1 + floor ((end - begin) * waveview->samples_per_unit);
1164  }
1165 
1166 #if 0
1167  printf ("0x%x r (%d..%d)(%d..%d) bbox (%d..%d)(%d..%d)"
1168  " b/e %d..%d s= %lu..%lu @ %f\n",
1169  waveview,
1170  buf->rect.x0,
1171  buf->rect.x1,
1172  buf->rect.y0,
1173  buf->rect.y1,
1174  waveview->bbox_ulx,
1175  waveview->bbox_lrx,
1176  waveview->bbox_uly,
1177  waveview->bbox_lry,
1178  begin, end, s1, s2,
1179  waveview->samples_per_unit);
1180 #endif
1181 
1182  /* now ensure that the cache is full and properly
1183  positioned.
1184  */
1185 
1186 // check_cache (waveview, "pre-ensure");
1187 
1188  if (waveview->cache_updater && waveview->reload_cache_in_render) {
1189  waveview->cache->start = 0;
1190  waveview->cache->end = 0;
1191  waveview->reload_cache_in_render = FALSE;
1192  }
1193 
1194 // check_cache (waveview, "post-ensure");
1195 
1196  /* don't rectify at single-sample zoom */
1197  if (waveview->rectified && waveview->samples_per_unit > 1) {
1198  rectify = TRUE;
1199  }
1200  else {
1201  rectify = FALSE;
1202  }
1203 
1204  clip_length = MIN(5,(waveview->height/4));
1205 
1206  /*
1207  Now draw each line, clipping it appropriately. The clipping
1208  is done by the macros PAINT_FOO().
1209  */
1210 
1211  half_height = waveview->half_height;
1212 
1213 /* this makes it slightly easier to comprehend whats going on */
1214 #define origin half_height
1215 
1216  if (waveview->filled && !rectify) {
1217  int prev_pymin = 1;
1218  int prev_pymax = 0;
1219  int last_pymin = 1;
1220  int last_pymax = 0;
1221  int next_pymin, next_pymax;
1222  double max, min;
1223  int next_clip_max = 0;
1224  int next_clip_min = 0;
1225 
1226  int wave_middle = (int) rint ((item->y1 + origin) * item->canvas->pixels_per_unit);
1227  int wave_top = (int) rint ((item->y1) * item->canvas->pixels_per_unit);
1228 
1229  if (s1 < waveview->samples_per_unit) {
1230  /* we haven't got a prev vars to compare with, so outline the whole line here */
1231  prev_pymax = (int) rint ((item->y1 + origin) * item->canvas->pixels_per_unit);
1232  prev_pymin = prev_pymax;
1233  }
1234  else {
1235  s1 -= waveview->samples_per_unit;
1236  }
1237 
1238  if(end == waveview->bbox_lrx) {
1239  /* we don't have the NEXT vars for the last sample */
1240  last_pymax = (int) rint ((item->y1 + origin) * item->canvas->pixels_per_unit);
1241  last_pymin = last_pymax;
1242  }
1243  else {
1244  s2 += waveview->samples_per_unit;
1245  }
1246 
1247  cache_index = gnome_canvas_waveview_ensure_cache (waveview, s1, s2);
1248 
1249  /*
1250  * Compute the variables outside the rendering rect
1251  */
1252  if(prev_pymax != prev_pymin) {
1253 
1254  prev_pymax = (int) rint ((item->y1 + origin - MIN(waveview->cache->data[cache_index].max, 1.0) * half_height) * item->canvas->pixels_per_unit);
1255  prev_pymin = (int) rint ((item->y1 + origin - MAX(waveview->cache->data[cache_index].min, -1.0) * half_height) * item->canvas->pixels_per_unit);
1256  ++cache_index;
1257  }
1258  if(last_pymax != last_pymin) {
1259  /* take the index of one sample right of what we render */
1260  guint index = cache_index + (end - begin);
1261 
1262  if (index >= waveview->cache->data_size) {
1263 
1264  /* the data we want is off the end of the cache, which must mean its beyond
1265  the end of the region's source; hence the peak values are 0 */
1266  last_pymax = (int) rint ((item->y1 + origin) * item->canvas->pixels_per_unit);
1267  last_pymin = (int) rint ((item->y1 + origin) * item->canvas->pixels_per_unit);
1268 
1269  } else {
1270 
1271  last_pymax = (int) rint ((item->y1 + origin - MIN(waveview->cache->data[index].max, 1.0) * half_height) * item->canvas->pixels_per_unit);
1272  last_pymin = (int) rint ((item->y1 + origin - MAX(waveview->cache->data[index].min, -1.0) * half_height) * item->canvas->pixels_per_unit);
1273 
1274  }
1275 
1276  }
1277 
1278  /*
1279  * initialize NEXT* variables for the first run, duplicated in the loop for speed
1280  */
1281  max = waveview->cache->data[cache_index].max;
1282  min = waveview->cache->data[cache_index].min;
1283 
1284  if (max >= 1.0) {
1285  max = 1.0;
1286  next_clip_max = 1;
1287  }
1288 
1289  if (min <= -1.0) {
1290  min = -1.0;
1291  next_clip_min = 1;
1292  }
1293 
1294  max *= half_height;
1295  min *= half_height;
1296 
1297  next_pymax = (int) rint ((item->y1 + origin - max) * item->canvas->pixels_per_unit);
1298  next_pymin = (int) rint ((item->y1 + origin - min) * item->canvas->pixels_per_unit);
1299 
1300  /*
1301  * And now the loop
1302  */
1303  for(x = begin; x < end; ++x) {
1304  int clip_max = next_clip_max;
1305  int clip_min = next_clip_min;
1306  int fill_max, fill_min;
1307 
1308  pymax = next_pymax;
1309  pymin = next_pymin;
1310 
1311  /* compute next */
1312  if(x == end - 1) {
1313  /*next is now the last column, which is outside the rendering rect, and possibly outside the region*/
1314  next_pymax = last_pymax;
1315  next_pymin = last_pymin;
1316  }
1317  else {
1318  ++cache_index;
1319 
1320  if (cache_index < waveview->cache->data_size) {
1321  max = waveview->cache->data[cache_index].max;
1322  min = waveview->cache->data[cache_index].min;
1323  } else {
1324  max = min = 0;
1325  }
1326 
1327  next_clip_max = 0;
1328  next_clip_min = 0;
1329 
1330  if (max >= 1.0) {
1331  max = 1.0;
1332  next_clip_max = 1;
1333  }
1334 
1335  if (min <= -1.0) {
1336  min = -1.0;
1337  next_clip_min = 1;
1338  }
1339 
1340  max *= half_height;
1341  min *= half_height;
1342 
1343  next_pymax = (int) rint ((item->y1 + origin - max) * item->canvas->pixels_per_unit);
1344  next_pymin = (int) rint ((item->y1 + origin - min) * item->canvas->pixels_per_unit);
1345  }
1346 
1347  /* render */
1348  if (pymax == pymin) {
1349  PAINT_DOTA(buf, waveview->wave_r, waveview->wave_g, waveview->wave_b, waveview->wave_a, x, pymin);
1350  } else {
1351  if((prev_pymax < pymax && next_pymax < pymax) ||
1352  (prev_pymax == pymax && next_pymax == pymax)) {
1353  fill_max = pymax + 1;
1354  PAINT_DOTA(buf, waveview->wave_r, waveview->wave_g, waveview->wave_b, waveview->wave_a, x, pymax);
1355  }
1356  else {
1357  fill_max = MAX(prev_pymax, next_pymax);
1358  if(pymax == fill_max) {
1359  PAINT_DOTA(buf, waveview->wave_r, waveview->wave_g, waveview->wave_b, waveview->wave_a, x, pymax);
1360  ++fill_max;
1361  } else {
1362  PAINT_VERTA_GR(buf, waveview->wave_r, waveview->wave_g, waveview->wave_b, waveview->wave_a, x, pymax, fill_max, wave_middle, wave_top);
1363  }
1364 
1365  }
1366 
1367  if((prev_pymin > pymin && next_pymin > pymin) ||
1368  (prev_pymin == pymin && next_pymin == pymin)) {
1369  fill_min = pymin - 1;
1370  PAINT_DOTA(buf, waveview->wave_r, waveview->wave_g, waveview->wave_b, waveview->wave_a, x, pymin-1);
1371  }
1372  else {
1373  fill_min = MIN(prev_pymin, next_pymin);
1374  if(pymin == fill_min) {
1375  PAINT_DOTA(buf, waveview->wave_r, waveview->wave_g, waveview->wave_b, waveview->wave_a, x, pymin);
1376  }
1377  else {
1378  PAINT_VERTA_GR(buf, waveview->wave_r, waveview->wave_g, waveview->wave_b, waveview->wave_a, x, fill_min, pymin, wave_middle, wave_top);
1379  }
1380  }
1381 
1382  if(fill_max < fill_min) {
1383  PAINT_VERTA_GR(buf, waveview->fill_r, waveview->fill_g, waveview->fill_b, waveview->fill_a, x, fill_max, fill_min, wave_middle, wave_top);
1384  }
1385  else if(fill_max == fill_min) {
1386  PAINT_DOTA(buf, waveview->fill_r, waveview->fill_g, waveview->fill_b, waveview->fill_a, x, fill_max);
1387  }
1388  }
1389 
1390  if (clip_max) {
1391  PAINT_VERTA(buf, waveview->clip_r, waveview->clip_g, waveview->clip_b, waveview->clip_a, x, pymax, pymax + clip_length);
1392  PAINT_VERTA(buf, waveview->clip_r, waveview->clip_g, waveview->clip_b, waveview->clip_a >> 1, x + 1, pymax, pymax + (clip_length -1));
1393  PAINT_VERTA(buf, waveview->clip_r, waveview->clip_g, waveview->clip_b, waveview->clip_a >> 1, x - 1, pymax, pymax + (clip_length - 1));
1394 
1395  }
1396 
1397  if (clip_min) {
1398  PAINT_VERTA(buf, waveview->clip_r, waveview->clip_g, waveview->clip_b, waveview->clip_a , x, pymin - clip_length, pymin);
1399  PAINT_VERTA(buf, waveview->clip_r, waveview->clip_g, waveview->clip_b, waveview->clip_a >> 1, x + 1, pymin - (clip_length - 1), pymin);
1400  PAINT_VERTA(buf, waveview->clip_r, waveview->clip_g, waveview->clip_b, waveview->clip_a >> 1, x - 1, pymin - (clip_length - 1), pymin);
1401  }
1402 
1403  prev_pymax = pymax;
1404  prev_pymin = pymin;
1405  }
1406 
1407  } else if (waveview->filled && rectify) {
1408 
1409  int prev_pymax = -1;
1410  int last_pymax = -1;
1411  int next_pymax;
1412  double max, min;
1413  int next_clip_max = 0;
1414  int next_clip_min = 0;
1415 
1416  int wave_middle = (int) rint ((item->y1 + waveview->height) * item->canvas->pixels_per_unit);
1417  int wave_top = (int) rint ((item->y1) * item->canvas->pixels_per_unit);
1418 
1419  // for rectified, this stays constant throughout the loop
1420  pymin = (int) rint ((item->y1 + waveview->height) * item->canvas->pixels_per_unit);
1421 
1422  if(s1 < waveview->samples_per_unit) {
1423  /* we haven't got a prev vars to compare with, so outline the whole line here */
1424  prev_pymax = pymin;
1425  }
1426  else {
1427  s1 -= waveview->samples_per_unit;
1428  }
1429 
1430  if(end == waveview->bbox_lrx) {
1431  /* we don't have the NEXT vars for the last sample */
1432  last_pymax = pymin;
1433  }
1434  else {
1435  s2 += waveview->samples_per_unit;
1436  }
1437 
1438  cache_index = gnome_canvas_waveview_ensure_cache (waveview, s1, s2);
1439 
1440  /*
1441  * Compute the variables outside the rendering rect
1442  */
1443  if(prev_pymax < 0) {
1444  max = MIN(waveview->cache->data[cache_index].max, 1.0);
1445  min = MAX(waveview->cache->data[cache_index].min, -1.0);
1446 
1447  if (fabs (min) > fabs (max)) {
1448  max = fabs (min);
1449  }
1450 
1451  prev_pymax = (int) rint ((item->y1 + waveview->height - max * waveview->height) * item->canvas->pixels_per_unit);
1452  ++cache_index;
1453  }
1454  if(last_pymax < 0) {
1455  /* take the index of one sample right of what we render */
1456  int index = cache_index + (end - begin);
1457 
1458  max = MIN(waveview->cache->data[index].max, 1.0);
1459  min = MAX(waveview->cache->data[index].min, -1.0);
1460 
1461  if (fabs (min) > fabs (max)) {
1462  max = fabs (min);
1463  }
1464 
1465  last_pymax = (int) rint ((item->y1 + waveview->height - max * waveview->height) * item->canvas->pixels_per_unit);
1466  }
1467 
1468  /*
1469  * initialize NEXT* variables for the first run, duplicated in the loop for speed
1470  */
1471  max = waveview->cache->data[cache_index].max;
1472  min = waveview->cache->data[cache_index].min;
1473 
1474  if (max >= 1.0) {
1475  max = 1.0;
1476  next_clip_max = 1;
1477  }
1478 
1479  if (min <= -1.0) {
1480  min = -1.0;
1481  next_clip_min = 1;
1482  }
1483 
1484  if (fabs (min) > fabs (max)) {
1485  max = fabs (min);
1486  }
1487 
1488  next_pymax = (int) rint ((item->y1 + waveview->height - max * waveview->height) * item->canvas->pixels_per_unit);
1489 
1490  /*
1491  * And now the loop
1492  */
1493  for(x = begin; x < end; ++x) {
1494  int clip_max = next_clip_max;
1495  int clip_min = next_clip_min;
1496  int fill_max;
1497 
1498  pymax = next_pymax;
1499 
1500  /* compute next */
1501  if(x == end - 1) {
1502  /*next is now the last column, which is outside the rendering rect, and possibly outside the region*/
1503  next_pymax = last_pymax;
1504  }
1505  else {
1506  ++cache_index;
1507 
1508  max = waveview->cache->data[cache_index].max;
1509  min = waveview->cache->data[cache_index].min;
1510 
1511  if (max >= 1.0) {
1512  max = 1.0;
1513  next_clip_max = 1;
1514  }
1515 
1516  if (min <= -1.0) {
1517  min = -1.0;
1518  next_clip_min = 1;
1519  }
1520 
1521  if (fabs (min) > fabs (max)) {
1522  max = fabs (min);
1523  }
1524 
1525  next_pymax = (int) rint ((item->y1 + waveview->height - max * waveview->height) * item->canvas->pixels_per_unit);
1526  }
1527 
1528  /* render */
1529  if (pymax == pymin) {
1530  PAINT_DOTA(buf, waveview->wave_r, waveview->wave_g, waveview->wave_b, waveview->wave_a, x, pymin);
1531  } else {
1532  if((prev_pymax < pymax && next_pymax < pymax) ||
1533  (prev_pymax == pymax && next_pymax == pymax)) {
1534  fill_max = pymax + 1;
1535  PAINT_DOTA(buf, waveview->wave_r, waveview->wave_g, waveview->wave_b, waveview->wave_a, x, pymax);
1536  }
1537  else {
1538  fill_max = MAX(prev_pymax, next_pymax);
1539  if(pymax == fill_max) {
1540  PAINT_DOTA(buf, waveview->wave_r, waveview->wave_g, waveview->wave_b, waveview->wave_a, x, pymax);
1541  ++fill_max;
1542  }
1543  else {
1544  PAINT_VERTA_GR(buf, waveview->wave_r, waveview->wave_g, waveview->wave_b, waveview->wave_a, x, pymax, fill_max, wave_middle, wave_top);
1545  }
1546  }
1547 
1548  if(fill_max < pymin) {
1549  PAINT_VERTA(buf, waveview->fill_r, waveview->fill_g, waveview->fill_b, waveview->fill_a, x, fill_max, pymin);
1550  }
1551  else if(fill_max == pymin) {
1552  PAINT_DOTA(buf, waveview->fill_r, waveview->fill_g, waveview->fill_b, waveview->fill_a, x, pymin);
1553  }
1554  }
1555 
1556  if (clip_max) {
1557  PAINT_VERTA(buf, waveview->clip_r, waveview->clip_g, waveview->clip_b, waveview->clip_a, x, pymax, pymax + clip_length);
1558  PAINT_VERTA(buf, waveview->clip_r, waveview->clip_g, waveview->clip_b, waveview->clip_a >> 1, x + 1, pymax, pymax + (clip_length -1));
1559  PAINT_VERTA(buf, waveview->clip_r, waveview->clip_g, waveview->clip_b, waveview->clip_a >> 1, x - 1, pymax, pymax + (clip_length - 1));
1560  }
1561 
1562  if (clip_min) {
1563  PAINT_VERTA(buf, waveview->clip_r, waveview->clip_g, waveview->clip_b, waveview->clip_a , x, pymin - clip_length, pymin);
1564  PAINT_VERTA(buf, waveview->clip_r, waveview->clip_g, waveview->clip_b, waveview->clip_a >> 1, x + 1, pymin - (clip_length - 1), pymin);
1565  PAINT_VERTA(buf, waveview->clip_r, waveview->clip_g, waveview->clip_b, waveview->clip_a >> 1, x - 1, pymin - (clip_length - 1), pymin);
1566  }
1567 
1568  prev_pymax = pymax;
1569  }
1570  }
1571  else {
1572  cache_index = gnome_canvas_waveview_ensure_cache (waveview, s1, s2);
1573 
1574  for (x = begin; x < end; x++) {
1575 
1576  double max, min;
1577  int clip_max, clip_min;
1578 
1579  clip_max = 0;
1580  clip_min = 0;
1581 
1582  max = waveview->cache->data[cache_index].max;
1583  min = waveview->cache->data[cache_index].min;
1584 
1585  if (max >= 1.0) {
1586  max = 1.0;
1587  clip_max = 1;
1588  }
1589 
1590  if (min <= -1.0) {
1591  min = -1.0;
1592  clip_min = 1;
1593  }
1594 
1595  if (rectify) {
1596 
1597  if (fabs (min) > fabs (max)) {
1598  max = fabs (min);
1599  }
1600 
1601  max = max * waveview->height;
1602 
1603  pymax = (int) rint ((item->y1 + waveview->height - max) * item->canvas->pixels_per_unit);
1604  pymin = (int) rint ((item->y1 + waveview->height) * item->canvas->pixels_per_unit);
1605 
1606  } else {
1607 
1608  max = max * half_height;
1609  min = min * half_height;
1610 
1611  pymax = (int) rint ((item->y1 + origin - max) * item->canvas->pixels_per_unit);
1612  pymin = (int) rint ((item->y1 + origin - min) * item->canvas->pixels_per_unit);
1613  }
1614 
1615  /* OK, now fill the RGB buffer at x=i with a line between pymin and pymax,
1616  or, if samples_per_unit == 1, then a dot at each location.
1617  */
1618 
1619  if (pymax == pymin) {
1620  PAINT_DOTA(buf, waveview->wave_r, waveview->wave_g, waveview->wave_b, waveview->wave_a, x, pymin);
1621  } else {
1622  PAINT_VERTA(buf, waveview->wave_r, waveview->wave_g, waveview->wave_b, waveview->wave_a, x, pymax, pymin);
1623  }
1624 
1625  /* show clipped waveforms with small red lines */
1626 
1627  if (clip_max) {
1628  PAINT_VERTA(buf, waveview->clip_r, waveview->clip_g, waveview->clip_b, waveview->clip_a, x, pymax, pymax+clip_length);
1629  }
1630 
1631  if (clip_min) {
1632  PAINT_VERTA(buf, waveview->clip_r, waveview->clip_g, waveview->clip_b, waveview->clip_a, x, pymin-clip_length, pymin);
1633  }
1634 
1635  /* presto, we're done */
1636 
1637  cache_index++;
1638  }
1639  }
1640 
1641  if (!waveview->rectified && waveview->zero_line && waveview->height >= 100) {
1642  // Paint zeroline.
1643 
1644  unsigned char zero_r, zero_g, zero_b, zero_a;
1645  UINT_TO_RGBA( waveview->zero_color, &zero_r, &zero_g, &zero_b, &zero_a);
1646  int zeroline_y = (int) rint ((item->y1 + origin) * item->canvas->pixels_per_unit);
1647  PAINT_HORIZA(buf, zero_r, zero_g, zero_b, zero_a, zbegin, zend, zeroline_y);
1648  }
1649 #undef origin
1650 
1651 }
1652 
1653 static void
1654 gnome_canvas_waveview_flat_render (GnomeCanvasItem *item,
1655  GnomeCanvasBuf *buf)
1656 {
1657  GnomeCanvasWaveView *waveview;
1658  gulong s1, s2;
1659  int clip_length = 0;
1660  int pymin, pymax;
1661  guint cache_index;
1662  double half_height;
1663  int x;
1664  char rectify;
1665 
1666  waveview = GNOME_CANVAS_WAVEVIEW (item);
1667 
1668 // check_cache (waveview, "start of render");
1669 
1670  if (parent_class->render) {
1671  (*parent_class->render) (item, buf);
1672  }
1673 
1674  if (buf->is_bg) {
1675  gnome_canvas_buf_ensure_buf (buf);
1676  buf->is_bg = FALSE;
1677  }
1678 
1679  /* a "unit" means a pixel */
1680 
1681  /* begin: render start x (units) */
1682  int const begin = MAX (waveview->bbox_ulx, buf->rect.x0);
1683 
1684  /* zbegin: start x for zero line (units) */
1685  int const zbegin = (begin == waveview->bbox_ulx) ? (begin + 1) : begin;
1686 
1687  /* end: render end x (units) */
1688  int const end = (waveview->bbox_lrx >= 0) ? MIN (waveview->bbox_lrx,buf->rect.x1) : buf->rect.x1;
1689 
1690  /* zend: end x for zero-line (units) */
1691  int const zend = (end == waveview->bbox_lrx) ? (end - 1) : end;
1692 
1693  if (begin == end) {
1694  return;
1695  }
1696 
1697  /* s1: start sample
1698  s2: end sample
1699  */
1700 
1701  s1 = floor ((begin - waveview->bbox_ulx) * waveview->samples_per_unit);
1702 
1703  // fprintf (stderr, "0x%x begins at sample %f\n", waveview, waveview->bbox_ulx * waveview->samples_per_unit);
1704 
1705  if (end == waveview->bbox_lrx) {
1706  /* This avoids minor rounding errors when we have the
1707  entire region visible.
1708  */
1709  s2 = waveview->samples;
1710  } else {
1711  s2 = s1 + floor ((end - begin) * waveview->samples_per_unit);
1712  }
1713 
1714 #if 0
1715  printf ("0x%x r (%d..%d)(%d..%d) bbox (%d..%d)(%d..%d)"
1716  " b/e %d..%d s= %lu..%lu @ %f\n",
1717  waveview,
1718  buf->rect.x0,
1719  buf->rect.x1,
1720  buf->rect.y0,
1721  buf->rect.y1,
1722  waveview->bbox_ulx,
1723  waveview->bbox_lrx,
1724  waveview->bbox_uly,
1725  waveview->bbox_lry,
1726  begin, end, s1, s2,
1727  waveview->samples_per_unit);
1728 #endif
1729 
1730  /* now ensure that the cache is full and properly
1731  positioned.
1732  */
1733 
1734 // check_cache (waveview, "pre-ensure");
1735 
1736  if (waveview->cache_updater && waveview->reload_cache_in_render) {
1737  waveview->cache->start = 0;
1738  waveview->cache->end = 0;
1739  waveview->reload_cache_in_render = FALSE;
1740  }
1741 
1742 // check_cache (waveview, "post-ensure");
1743 
1744  /* don't rectify at single-sample zoom */
1745  if (waveview->rectified && waveview->samples_per_unit > 1) {
1746  rectify = TRUE;
1747  }
1748  else {
1749  rectify = FALSE;
1750  }
1751 
1752  clip_length = MIN(5,(waveview->height/4));
1753 
1754  /*
1755  Now draw each line, clipping it appropriately. The clipping
1756  is done by the macros PAINT_FOO().
1757  */
1758 
1759  half_height = waveview->half_height;
1760 
1761 /* this makes it slightly easier to comprehend whats going on */
1762 #define origin half_height
1763 
1764  if (waveview->filled && !rectify) {
1765  int prev_pymin = 1;
1766  int prev_pymax = 0;
1767  int last_pymin = 1;
1768  int last_pymax = 0;
1769  int next_pymin, next_pymax;
1770  double max, min;
1771  int next_clip_max = 0;
1772  int next_clip_min = 0;
1773 
1774  if (s1 < waveview->samples_per_unit) {
1775  /* we haven't got a prev vars to compare with, so outline the whole line here */
1776  prev_pymax = (int) rint ((item->y1 + origin) * item->canvas->pixels_per_unit);
1777  prev_pymin = prev_pymax;
1778  }
1779  else {
1780  s1 -= waveview->samples_per_unit;
1781  }
1782 
1783  if(end == waveview->bbox_lrx) {
1784  /* we don't have the NEXT vars for the last sample */
1785  last_pymax = (int) rint ((item->y1 + origin) * item->canvas->pixels_per_unit);
1786  last_pymin = last_pymax;
1787  }
1788  else {
1789  s2 += waveview->samples_per_unit;
1790  }
1791 
1792  cache_index = gnome_canvas_waveview_ensure_cache (waveview, s1, s2);
1793 
1794  /*
1795  * Compute the variables outside the rendering rect
1796  */
1797  if(prev_pymax != prev_pymin) {
1798 
1799  prev_pymax = (int) rint ((item->y1 + origin - MIN(waveview->cache->data[cache_index].max, 1.0) * half_height) * item->canvas->pixels_per_unit);
1800  prev_pymin = (int) rint ((item->y1 + origin - MAX(waveview->cache->data[cache_index].min, -1.0) * half_height) * item->canvas->pixels_per_unit);
1801  ++cache_index;
1802  }
1803  if(last_pymax != last_pymin) {
1804  /* take the index of one sample right of what we render */
1805  guint index = cache_index + (end - begin);
1806 
1807  if (index >= waveview->cache->data_size) {
1808 
1809  /* the data we want is off the end of the cache, which must mean its beyond
1810  the end of the region's source; hence the peak values are 0 */
1811  last_pymax = (int) rint ((item->y1 + origin) * item->canvas->pixels_per_unit);
1812  last_pymin = (int) rint ((item->y1 + origin) * item->canvas->pixels_per_unit);
1813 
1814  } else {
1815 
1816  last_pymax = (int) rint ((item->y1 + origin - MIN(waveview->cache->data[index].max, 1.0) * half_height) * item->canvas->pixels_per_unit);
1817  last_pymin = (int) rint ((item->y1 + origin - MAX(waveview->cache->data[index].min, -1.0) * half_height) * item->canvas->pixels_per_unit);
1818 
1819  }
1820 
1821  }
1822 
1823  /*
1824  * initialize NEXT* variables for the first run, duplicated in the loop for speed
1825  */
1826  max = waveview->cache->data[cache_index].max;
1827  min = waveview->cache->data[cache_index].min;
1828 
1829  if (max >= 1.0) {
1830  max = 1.0;
1831  next_clip_max = 1;
1832  }
1833 
1834  if (min <= -1.0) {
1835  min = -1.0;
1836  next_clip_min = 1;
1837  }
1838 
1839  max *= half_height;
1840  min *= half_height;
1841 
1842  next_pymax = (int) rint ((item->y1 + origin - max) * item->canvas->pixels_per_unit);
1843  next_pymin = (int) rint ((item->y1 + origin - min) * item->canvas->pixels_per_unit);
1844 
1845  /*
1846  * And now the loop
1847  */
1848  for(x = begin; x < end; ++x) {
1849  int clip_max = next_clip_max;
1850  int clip_min = next_clip_min;
1851  int fill_max, fill_min;
1852 
1853  pymax = next_pymax;
1854  pymin = next_pymin;
1855 
1856  /* compute next */
1857  if(x == end - 1) {
1858  /*next is now the last column, which is outside the rendering rect, and possibly outside the region*/
1859  next_pymax = last_pymax;
1860  next_pymin = last_pymin;
1861  }
1862  else {
1863  ++cache_index;
1864 
1865  if (cache_index < waveview->cache->data_size) {
1866  max = waveview->cache->data[cache_index].max;
1867  min = waveview->cache->data[cache_index].min;
1868  } else {
1869  max = min = 0;
1870  }
1871 
1872  next_clip_max = 0;
1873  next_clip_min = 0;
1874 
1875  if (max >= 1.0) {
1876  max = 1.0;
1877  next_clip_max = 1;
1878  }
1879 
1880  if (min <= -1.0) {
1881  min = -1.0;
1882  next_clip_min = 1;
1883  }
1884 
1885  max *= half_height;
1886  min *= half_height;
1887 
1888  next_pymax = (int) rint ((item->y1 + origin - max) * item->canvas->pixels_per_unit);
1889  next_pymin = (int) rint ((item->y1 + origin - min) * item->canvas->pixels_per_unit);
1890  }
1891 
1892  /* render */
1893  if (pymax == pymin) {
1894  PAINT_DOTA(buf, waveview->wave_r, waveview->wave_g, waveview->wave_b, waveview->wave_a, x, pymin);
1895  } else {
1896  if((prev_pymax < pymax && next_pymax < pymax) ||
1897  (prev_pymax == pymax && next_pymax == pymax)) {
1898  fill_max = pymax + 1;
1899  PAINT_DOTA(buf, waveview->wave_r, waveview->wave_g, waveview->wave_b, waveview->wave_a, x, pymax);
1900  }
1901  else {
1902  fill_max = MAX(prev_pymax, next_pymax);
1903  if(pymax == fill_max) {
1904  PAINT_DOTA(buf, waveview->wave_r, waveview->wave_g, waveview->wave_b, waveview->wave_a, x, pymax);
1905  ++fill_max;
1906  }
1907  else {
1908  PAINT_VERTA(buf, waveview->wave_r, waveview->wave_g, waveview->wave_b, waveview->wave_a, x, pymax, fill_max);
1909  }
1910  }
1911 
1912  if((prev_pymin > pymin && next_pymin > pymin) ||
1913  (prev_pymin == pymin && next_pymin == pymin)) {
1914  fill_min = pymin - 1;
1915  PAINT_DOTA(buf, waveview->wave_r, waveview->wave_g, waveview->wave_b, waveview->wave_a, x, pymin-1);
1916  }
1917  else {
1918  fill_min = MIN(prev_pymin, next_pymin);
1919  if(pymin == fill_min) {
1920  PAINT_DOTA(buf, waveview->wave_r, waveview->wave_g, waveview->wave_b, waveview->wave_a, x, pymin);
1921  }
1922  else {
1923  PAINT_VERTA(buf, waveview->wave_r, waveview->wave_g, waveview->wave_b, waveview->wave_a, x, fill_min, pymin);
1924  }
1925  }
1926 
1927  if(fill_max < fill_min) {
1928  PAINT_VERTA(buf, waveview->fill_r, waveview->fill_g, waveview->fill_b, waveview->fill_a, x, fill_max, fill_min);
1929  }
1930  else if(fill_max == fill_min) {
1931  PAINT_DOTA(buf, waveview->fill_r, waveview->fill_g, waveview->fill_b, waveview->fill_a, x, fill_max);
1932  }
1933  }
1934 
1935  if (clip_max) {
1936  PAINT_VERTA(buf, waveview->clip_r, waveview->clip_g, waveview->clip_b, waveview->clip_a, x, pymax, pymax+clip_length);
1937  }
1938 
1939  if (clip_min) {
1940  PAINT_VERTA(buf, waveview->clip_r, waveview->clip_g, waveview->clip_b, waveview->clip_a, x, pymin-clip_length, pymin);
1941  }
1942 
1943  prev_pymax = pymax;
1944  prev_pymin = pymin;
1945  }
1946 
1947  } else if (waveview->filled && rectify) {
1948 
1949  int prev_pymax = -1;
1950  int last_pymax = -1;
1951  int next_pymax;
1952  double max, min;
1953  int next_clip_max = 0;
1954  int next_clip_min = 0;
1955 
1956  // for rectified, this stays constant throughout the loop
1957  pymin = (int) rint ((item->y1 + waveview->height) * item->canvas->pixels_per_unit);
1958 
1959  if(s1 < waveview->samples_per_unit) {
1960  /* we haven't got a prev vars to compare with, so outline the whole line here */
1961  prev_pymax = pymin;
1962  }
1963  else {
1964  s1 -= waveview->samples_per_unit;
1965  }
1966 
1967  if(end == waveview->bbox_lrx) {
1968  /* we don't have the NEXT vars for the last sample */
1969  last_pymax = pymin;
1970  }
1971  else {
1972  s2 += waveview->samples_per_unit;
1973  }
1974 
1975  cache_index = gnome_canvas_waveview_ensure_cache (waveview, s1, s2);
1976 
1977  /*
1978  * Compute the variables outside the rendering rect
1979  */
1980  if(prev_pymax < 0) {
1981  max = MIN(waveview->cache->data[cache_index].max, 1.0);
1982  min = MAX(waveview->cache->data[cache_index].min, -1.0);
1983 
1984  if (fabs (min) > fabs (max)) {
1985  max = fabs (min);
1986  }
1987 
1988  prev_pymax = (int) rint ((item->y1 + waveview->height - max * waveview->height) * item->canvas->pixels_per_unit);
1989  ++cache_index;
1990  }
1991  if(last_pymax < 0) {
1992  /* take the index of one sample right of what we render */
1993  int index = cache_index + (end - begin);
1994 
1995  max = MIN(waveview->cache->data[index].max, 1.0);
1996  min = MAX(waveview->cache->data[index].min, -1.0);
1997 
1998  if (fabs (min) > fabs (max)) {
1999  max = fabs (min);
2000  }
2001 
2002  last_pymax = (int) rint ((item->y1 + waveview->height - max * waveview->height) * item->canvas->pixels_per_unit);
2003  }
2004 
2005  /*
2006  * initialize NEXT* variables for the first run, duplicated in the loop for speed
2007  */
2008  max = waveview->cache->data[cache_index].max;
2009  min = waveview->cache->data[cache_index].min;
2010 
2011  if (max >= 1.0) {
2012  max = 1.0;
2013  next_clip_max = 1;
2014  }
2015 
2016  if (min <= -1.0) {
2017  min = -1.0;
2018  next_clip_min = 1;
2019  }
2020 
2021  if (fabs (min) > fabs (max)) {
2022  max = fabs (min);
2023  }
2024 
2025  next_pymax = (int) rint ((item->y1 + waveview->height - max * waveview->height) * item->canvas->pixels_per_unit);
2026 
2027  /*
2028  * And now the loop
2029  */
2030  for(x = begin; x < end; ++x) {
2031  int clip_max = next_clip_max;
2032  int clip_min = next_clip_min;
2033  int fill_max;
2034 
2035  pymax = next_pymax;
2036 
2037  /* compute next */
2038  if(x == end - 1) {
2039  /*next is now the last column, which is outside the rendering rect, and possibly outside the region*/
2040  next_pymax = last_pymax;
2041  }
2042  else {
2043  ++cache_index;
2044 
2045  max = waveview->cache->data[cache_index].max;
2046  min = waveview->cache->data[cache_index].min;
2047 
2048  if (max >= 1.0) {
2049  max = 1.0;
2050  next_clip_max = 1;
2051  }
2052 
2053  if (min <= -1.0) {
2054  min = -1.0;
2055  next_clip_min = 1;
2056  }
2057 
2058  if (fabs (min) > fabs (max)) {
2059  max = fabs (min);
2060  }
2061 
2062  next_pymax = (int) rint ((item->y1 + waveview->height - max * waveview->height) * item->canvas->pixels_per_unit);
2063  }
2064 
2065  /* render */
2066  if (pymax == pymin) {
2067  PAINT_DOTA(buf, waveview->wave_r, waveview->wave_g, waveview->wave_b, waveview->wave_a, x, pymin);
2068  } else {
2069  if((prev_pymax < pymax && next_pymax < pymax) ||
2070  (prev_pymax == pymax && next_pymax == pymax)) {
2071  fill_max = pymax + 1;
2072  PAINT_DOTA(buf, waveview->wave_r, waveview->wave_g, waveview->wave_b, waveview->wave_a, x, pymax);
2073  }
2074  else {
2075  fill_max = MAX(prev_pymax, next_pymax);
2076  if(pymax == fill_max) {
2077  PAINT_DOTA(buf, waveview->wave_r, waveview->wave_g, waveview->wave_b, waveview->wave_a, x, pymax);
2078  ++fill_max;
2079  }
2080  else {
2081  PAINT_VERTA(buf, waveview->wave_r, waveview->wave_g, waveview->wave_b, waveview->wave_a, x, pymax, fill_max);
2082  }
2083  }
2084 
2085  if(fill_max < pymin) {
2086  PAINT_VERTA(buf, waveview->fill_r, waveview->fill_g, waveview->fill_b, waveview->fill_a, x, fill_max, pymin);
2087  }
2088  else if(fill_max == pymin) {
2089  PAINT_DOTA(buf, waveview->fill_r, waveview->fill_g, waveview->fill_b, waveview->fill_a, x, pymin);
2090  }
2091  }
2092 
2093  if (clip_max) {
2094  PAINT_VERTA(buf, waveview->clip_r, waveview->clip_g, waveview->clip_b, waveview->clip_a, x, pymax, pymax+clip_length);
2095  }
2096 
2097  if (clip_min) {
2098  PAINT_VERTA(buf, waveview->clip_r, waveview->clip_g, waveview->clip_b, waveview->clip_a, x, pymin-clip_length, pymin);
2099  }
2100 
2101  prev_pymax = pymax;
2102  }
2103  }
2104  else {
2105  cache_index = gnome_canvas_waveview_ensure_cache (waveview, s1, s2);
2106 
2107  for (x = begin; x < end; x++) {
2108 
2109  double max, min;
2110  int clip_max, clip_min;
2111 
2112  clip_max = 0;
2113  clip_min = 0;
2114 
2115  max = waveview->cache->data[cache_index].max;
2116  min = waveview->cache->data[cache_index].min;
2117 
2118  if (max >= 1.0) {
2119  max = 1.0;
2120  clip_max = 1;
2121  }
2122 
2123  if (min <= -1.0) {
2124  min = -1.0;
2125  clip_min = 1;
2126  }
2127 
2128  if (rectify) {
2129 
2130  if (fabs (min) > fabs (max)) {
2131  max = fabs (min);
2132  }
2133 
2134  max = max * waveview->height;
2135 
2136  pymax = (int) rint ((item->y1 + waveview->height - max) * item->canvas->pixels_per_unit);
2137  pymin = (int) rint ((item->y1 + waveview->height) * item->canvas->pixels_per_unit);
2138 
2139  } else {
2140 
2141  max = max * half_height;
2142  min = min * half_height;
2143 
2144  pymax = (int) rint ((item->y1 + origin - max) * item->canvas->pixels_per_unit);
2145  pymin = (int) rint ((item->y1 + origin - min) * item->canvas->pixels_per_unit);
2146  }
2147 
2148  /* OK, now fill the RGB buffer at x=i with a line between pymin and pymax,
2149  or, if samples_per_unit == 1, then a dot at each location.
2150  */
2151 
2152  if (pymax == pymin) {
2153  PAINT_DOTA(buf, waveview->wave_r, waveview->wave_g, waveview->wave_b, waveview->wave_a, x, pymin);
2154  } else {
2155  PAINT_VERTA(buf, waveview->wave_r, waveview->wave_g, waveview->wave_b, waveview->wave_a, x, pymax, pymin);
2156  }
2157 
2158  /* show clipped waveforms with small red lines */
2159 
2160  if (clip_max) {
2161  PAINT_VERTA(buf, waveview->clip_r, waveview->clip_g, waveview->clip_b, waveview->clip_a, x, pymax, pymax+clip_length);
2162  }
2163 
2164  if (clip_min) {
2165  PAINT_VERTA(buf, waveview->clip_r, waveview->clip_g, waveview->clip_b, waveview->clip_a, x, pymin-clip_length, pymin);
2166  }
2167 
2168  /* presto, we're done */
2169 
2170  cache_index++;
2171  }
2172  }
2173 
2174  if (!waveview->rectified && waveview->zero_line && waveview->height >= 100) {
2175  // Paint zeroline.
2176 
2177  unsigned char zero_r, zero_g, zero_b, zero_a;
2178  UINT_TO_RGBA( waveview->zero_color, &zero_r, &zero_g, &zero_b, &zero_a);
2179  int zeroline_y = (int) rint ((item->y1 + origin) * item->canvas->pixels_per_unit);
2180  PAINT_HORIZA(buf, zero_r, zero_g, zero_b, zero_a, zbegin, zend, zeroline_y);
2181  }
2182 #undef origin
2183 }
2184 
2185 static void
2186 gnome_canvas_waveview_render (GnomeCanvasItem *item,
2187  GnomeCanvasBuf *buf)
2188 {
2189  if (_gradient_rendering) {
2190  gnome_canvas_waveview_gradient_render (item, buf);
2191  } else {
2192  gnome_canvas_waveview_flat_render (item, buf);
2193  }
2194 }
2195 
2196 static void
2197 gnome_canvas_waveview_draw (GnomeCanvasItem *item,
2198  GdkDrawable *drawable,
2199  int x, int y,
2200  int width, int height)
2201 {
2202  GnomeCanvasWaveView *waveview;
2203  cairo_t* cr;
2204  gulong s1, s2;
2205  int cache_index;
2206  gboolean rectify;
2207  double origin;
2208  double xoff;
2209  double yoff = 0.0;
2210  double ulx;
2211  double uly;
2212  double lrx;
2213  double lry;
2214 
2215  waveview = GNOME_CANVAS_WAVEVIEW (item);
2216 
2217  /* compute intersection of Drawable area and waveview,
2218  in canvas coordinate space
2219  */
2220 
2221  if (x > waveview->bbox_ulx) {
2222  ulx = x;
2223  } else {
2224  ulx = waveview->bbox_ulx;
2225  }
2226 
2227  if (y > waveview->bbox_uly) {
2228  uly = y;
2229  } else {
2230  uly = waveview->bbox_uly;
2231  }
2232 
2233  if (x + width > waveview->bbox_lrx) {
2234  lrx = waveview->bbox_lrx;
2235  } else {
2236  lrx = x + width;
2237  }
2238 
2239  if (y + height > waveview->bbox_lry) {
2240  lry = waveview->bbox_lry;
2241  } else {
2242  lry = y + height;
2243  }
2244 
2245  /* figure out which samples we need for the resulting intersection */
2246 
2247  s1 = floor ((ulx - waveview->bbox_ulx) * waveview->samples_per_unit) ;
2248 
2249  if (lrx == waveview->bbox_lrx) {
2250  /* This avoids minor rounding errors when we have the
2251  entire region visible.
2252  */
2253  s2 = waveview->samples;
2254  } else {
2255  s2 = s1 + floor ((lrx - ulx) * waveview->samples_per_unit);
2256  }
2257 
2258  /* translate back to buffer coordinate space */
2259 
2260  ulx -= x;
2261  uly -= y;
2262  lrx -= x;
2263  lry -= y;
2264 
2265  /* don't rectify at single-sample zoom */
2266  if(waveview->rectified && waveview->samples_per_unit > 1.0) {
2267  rectify = TRUE;
2268  } else {
2269  rectify = FALSE;
2270  }
2271 
2272  cr = gdk_cairo_create (drawable);
2273  cairo_set_line_width (cr, 0.5);
2274 
2275  origin = waveview->bbox_uly - y + waveview->half_height;
2276 
2277  cairo_rectangle (cr, ulx, uly, lrx - ulx, lry - uly);
2278  cairo_clip (cr);
2279 
2280  if (waveview->cache_updater && waveview->reload_cache_in_render) {
2281  waveview->cache->start = 0;
2282  waveview->cache->end = 0;
2283  waveview->reload_cache_in_render = FALSE;
2284  }
2285 
2286  cache_index = gnome_canvas_waveview_ensure_cache (waveview, s1, s2);
2287 
2288 #if 0
2289  printf ("%p r (%d,%d)(%d,%d)[%d x %d] bbox (%d,%d)(%d,%d)[%d x %d]"
2290  " draw (%.1f,%.1f)(%.1f,%.1f)[%.1f x %.1f] s= %lu..%lu\n",
2291  waveview,
2292  x, y,
2293  x + width,
2294  y + height,
2295  width,
2296  height,
2297  waveview->bbox_ulx,
2298  waveview->bbox_uly,
2299  waveview->bbox_lrx,
2300  waveview->bbox_lry,
2301  waveview->bbox_lrx - waveview->bbox_ulx,
2302  waveview->bbox_lry - waveview->bbox_uly,
2303  ulx, uly,
2304  lrx, lry,
2305  lrx - ulx,
2306  lry - uly,
2307  s1, s2);
2308 #endif
2309 
2310  /* draw the top half */
2311 
2312  for (xoff = ulx; xoff < lrx; xoff++) {
2313  double max, min;
2314 
2315  max = waveview->cache->data[cache_index].max;
2316  min = waveview->cache->data[cache_index].min;
2317 
2318  if (min <= -1.0) {
2319  min = -1.0;
2320  }
2321 
2322  if (max >= 1.0) {
2323  max = 1.0;
2324  }
2325 
2326  if (rectify) {
2327  if (fabs (min) > fabs (max)) {
2328  max = fabs (min);
2329  }
2330  }
2331 
2332  yoff = origin - (waveview->half_height * max) + 0.5;
2333 
2334  if (xoff == ulx) {
2335  /* first point */
2336  cairo_move_to (cr, xoff+0.5, yoff);
2337  } else {
2338  cairo_line_to (cr, xoff+0.5, yoff);
2339  }
2340 
2341  cache_index++;
2342  }
2343 
2344  /* from the final top point, move out of the clip zone */
2345 
2346  cairo_line_to (cr, xoff + 10, yoff);
2347 
2348  /* now draw the bottom half */
2349 
2350  for (--xoff, --cache_index; xoff >= ulx; --xoff) {
2351  double min;
2352 
2353  min = waveview->cache->data[cache_index].min;
2354 
2355  if (min <= -1.0) {
2356  min = -1.0;
2357  }
2358 
2359  yoff = origin - (waveview->half_height * min) + 0.5;
2360 
2361  cairo_line_to (cr, xoff+0.5, yoff);
2362  cache_index--;
2363  }
2364 
2365  /* from the final lower point, move out of the clip zone */
2366 
2367  cairo_line_to (cr, xoff - 10, yoff);
2368 
2369  /* close path to fill */
2370 
2371  cairo_close_path (cr);
2372 
2373  /* fill and stroke */
2374 
2375  cairo_set_source_rgba (cr,
2376  (waveview->fill_r/255.0),
2377  (waveview->fill_g/255.0),
2378  (waveview->fill_b/255.0),
2379  (waveview->fill_a/255.0));
2380  cairo_fill_preserve (cr);
2381  cairo_set_source_rgba (cr,
2382  (waveview->wave_r/255.0),
2383  (waveview->wave_g/255.0),
2384  (waveview->wave_b/255.0),
2385  (waveview->wave_a/255.0));
2386  cairo_stroke (cr);
2387 
2388  cairo_destroy (cr);
2389 }
2390 
2391 #if 0
2392  if (clip_max || clip_min) {
2393  cairo_set_source_rgba (cr, waveview->clip_r, waveview->clip_g, waveview->clip_b, waveview->clip_a);
2394  }
2395 
2396  if (clip_max) {
2397  cairo_move_to (cr, xoff, yoff1);
2398  cairo_line_to (cr, xoff, yoff1 + clip_length);
2399  cairo_stroke (cr);
2400  }
2401 
2402  if (clip_min) {
2403  cairo_move_to (cr, xoff, yoff2);
2404  cairo_line_to (cr, xoff, yoff2 - clip_length);
2405  cairo_stroke (cr);
2406  }
2407 
2408 #endif
2409 
2410 static void
2411 gnome_canvas_waveview_bounds (GnomeCanvasItem *item, double *x1, double *y1, double *x2, double *y2)
2412 {
2413  GnomeCanvasWaveView *waveview = GNOME_CANVAS_WAVEVIEW (item);
2414 
2415  *x1 = waveview->x;
2416  *y1 = waveview->y;
2417 
2418  *x2 = ceil (*x1 + (waveview->length_function (waveview->data_src) / waveview->samples_per_unit));
2419  *y2 = *y1 + waveview->height;
2420 
2421 #if 0
2422  x = 0; y = 0;
2423  gnome_canvas_item_i2w (item, &x, &y);
2424  gnome_canvas_w2c_d (GNOME_CANVAS(item->canvas), x, y, &a, &b);
2425  x = *x2;
2426  y = *y2;
2427  gnome_canvas_item_i2w (item, &x, &y);
2428  gnome_canvas_w2c_d (GNOME_CANVAS(item->canvas), x, y, &c, &d);
2429  printf ("item bounds now (%g,%g),(%g,%g)\n", a, b, c, d);
2430 #endif
2431 
2432 }
2433 
2434 static double
2435 gnome_canvas_waveview_point (GnomeCanvasItem *item, double x, double y, int cx, int cy, GnomeCanvasItem **actual_item)
2436 {
2437  (void) item;
2438  (void) x;
2439  (void) y;
2440  (void) cx;
2441  (void) cy;
2442  (void) actual_item;
2443 
2444  /* XXX for now, point is never inside the wave
2445  GnomeCanvasWaveView *waveview;
2446  double x1, y1, x2, y2;
2447  double dx, dy;
2448  */
2449 
2450  return DBL_MAX;
2451 
2452 #if 0
2453  waveview = GNOME_CANVAS_WAVEVIEW (item);
2454 
2455  *actual_item = item;
2456 
2457  /* Find the bounds for the rectangle plus its outline width */
2458 
2459  gnome_canvas_waveview_bounds (item, &x1, &y1, &x2, &y2);
2460 
2461  /* Is point inside rectangle */
2462 
2463  if ((x >= x1) && (y >= y1) && (x <= x2) && (y <= y2)) {
2464  return 0.0;
2465  }
2466 
2467  /* Point is outside rectangle */
2468 
2469  if (x < x1)
2470  dx = x1 - x;
2471  else if (x > x2)
2472  dx = x - x2;
2473  else
2474  dx = 0.0;
2475 
2476  if (y < y1)
2477  dy = y1 - y;
2478  else if (y > y2)
2479  dy = y - y2;
2480  else
2481  dy = 0.0;
2482 
2483  return sqrt (dx * dx + dy * dy);
2484 #endif
2485 }
2486 
_GnomeCanvasWaveViewCache::end
gulong end
Definition: canvas-waveview.h:61
gnome_canvas_waveview_point
static double gnome_canvas_waveview_point(GnomeCanvasItem *item, double x, double y, int cx, int cy, GnomeCanvasItem **actual_item)
Definition: canvas-waveview.c:2435
_GnomeCanvasWaveView::y
double y
Definition: canvas-waveview.h:105
c_stacktrace
void c_stacktrace(void)
Definition: utils.cc:768
gnome_canvas_waveview_get_type
GType gnome_canvas_waveview_get_type(void)
Definition: canvas-waveview.c:130
_GnomeCanvasWaveViewCache::start
gulong start
Definition: canvas-waveview.h:60
fast_coefficient_to_dB
static float fast_coefficient_to_dB(float coeff)
Definition: dB.h:34
_GnomeCanvasWaveViewCache
Definition: canvas-waveview.h:55
_GnomeCanvasWaveView::fill_g
unsigned char fill_g
Definition: canvas-waveview.h:129
gnome_canvas_waveview_cache_new
GnomeCanvasWaveViewCache * gnome_canvas_waveview_cache_new(void)
Definition: canvas-waveview.c:341
MAX
#define MAX(a, b)
Definition: session_ltc.cc:42
gnome_canvas_waveview_set_data_src
static void gnome_canvas_waveview_set_data_src(GnomeCanvasWaveView *, void *)
Definition: canvas-waveview.c:687
_GnomeCanvasWaveViewCache::allocated
guint32 allocated
Definition: canvas-waveview.h:58
waveview_gain_curve_function_t
void(* waveview_gain_curve_function_t)(void *arg, double start, double end, float *vector, gint64 veclen)
Definition: canvas-waveview.h:71
gnome_canvas_waveview_cache_destroy
void gnome_canvas_waveview_cache_destroy(GnomeCanvasWaveViewCache *cache)
Definition: canvas-waveview.c:357
_GnomeCanvasWaveView::clip_a
unsigned char clip_a
Definition: canvas-waveview.h:128
_GnomeCanvasWaveView::wave_r
unsigned char wave_r
Definition: canvas-waveview.h:127
gnome_canvas_waveview_update
static void gnome_canvas_waveview_update(GnomeCanvasItem *item, double *affine, ArtSVP *clip_path, int flags)
Definition: canvas-waveview.c:1056
gnome_canvas_waveview_render
static void gnome_canvas_waveview_render(GnomeCanvasItem *item, GnomeCanvasBuf *buf)
Definition: canvas-waveview.c:2186
_GnomeCanvasWaveView::logscaled
char logscaled
Definition: canvas-waveview.h:116
parent_class
static GnomeCanvasItemClass * parent_class
Definition: canvas-waveview.c:127
PAINT_VERTA_GR
#define PAINT_VERTA_GR(inbuf, colr, colg, colb, cola, ptx, pty0, pty1, origin_y, obj_top)
Definition: rgb_macros.h:242
_GnomeCanvasWaveView::amplitude_above_axis
double amplitude_above_axis
Definition: canvas-waveview.h:102
_GnomeCanvasWaveView::peak_function
waveview_peak_function_t peak_function
Definition: canvas-waveview.h:84
_GnomeCanvasWaveView::clip_r
unsigned char clip_r
Definition: canvas-waveview.h:128
signals.f
tuple f
Definition: signals.py:35
gnome_canvas_waveview_destroy
static void gnome_canvas_waveview_destroy(GtkObject *object)
Definition: canvas-waveview.c:395
ARDOUR::Properties::gain
LIBARDOUR_API PBD::PropertyDescriptor< bool > gain
Definition: route_group.cc:44
_GnomeCanvasWaveView::clip_b
unsigned char clip_b
Definition: canvas-waveview.h:128
UINT_TO_RGBA
#define UINT_TO_RGBA(u, r, g, b, a)
Definition: fastmeter.cc:35
_GnomeCanvasWaveView::samples_per_unit
double samples_per_unit
Definition: canvas-waveview.h:91
_GnomeCanvasWaveView::wave_g
unsigned char wave_g
Definition: canvas-waveview.h:127
_GnomeCanvasWaveView::zero_line
char zero_line
Definition: canvas-waveview.h:115
_GnomeCanvasWaveViewCache::data
GnomeCanvasWaveViewCacheEntry * data
Definition: canvas-waveview.h:57
_GnomeCanvasWaveView::samples
uint32_t samples
Definition: canvas-waveview.h:130
origin
#define origin
waveview_length_function_t
gulong(* waveview_length_function_t)(void *)
Definition: canvas-waveview.h:69
_GnomeCanvasWaveView::length_function
waveview_length_function_t length_function
Definition: canvas-waveview.h:85
gnome_canvas_waveview_init
static void gnome_canvas_waveview_init(GnomeCanvasWaveView *waveview)
Definition: canvas-waveview.c:364
gnome_canvas_waveview_set_property
static void gnome_canvas_waveview_set_property(GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
Definition: canvas-waveview.c:747
PAINT_HORIZA
#define PAINT_HORIZA(inbuf, colr, colg, colb, cola, ptx0, ptx1, pty)
Definition: rgb_macros.h:167
_GnomeCanvasWaveView
Definition: canvas-waveview.h:74
_gradient_rendering
static int _gradient_rendering
Definition: canvas-waveview.c:125
_GnomeCanvasWaveView::filled
char filled
Definition: canvas-waveview.h:113
_GnomeCanvasWaveView::bbox_lry
int32_t bbox_lry
Definition: canvas-waveview.h:126
GNOME_CANVAS_WAVEVIEW
#define GNOME_CANVAS_WAVEVIEW(obj)
Definition: canvas-waveview.h:35
_GnomeCanvasWaveView::region_start
uint32_t region_start
Definition: canvas-waveview.h:131
_GnomeCanvasWaveView::wave_color
uint32_t wave_color
Definition: canvas-waveview.h:108
GnomeCanvasWaveViewClass
struct _GnomeCanvasWaveViewClass GnomeCanvasWaveViewClass
Definition: canvas-waveview.h:42
gnome_canvas_waveview_set_gradient_waveforms
void gnome_canvas_waveview_set_gradient_waveforms(int yn)
Definition: canvas-waveview.c:335
_GnomeCanvasWaveView::fill_a
unsigned char fill_a
Definition: canvas-waveview.h:129
GNOME_IS_CANVAS_WAVEVIEW
#define GNOME_IS_CANVAS_WAVEVIEW(obj)
Definition: canvas-waveview.h:37
_GnomeCanvasWaveView::bbox_uly
int32_t bbox_uly
Definition: canvas-waveview.h:124
gnome_canvas_waveview_reset_bounds
static void gnome_canvas_waveview_reset_bounds(GnomeCanvasItem *item)
Definition: canvas-waveview.c:714
_GnomeCanvasWaveView::cache_updater
gboolean cache_updater
Definition: canvas-waveview.h:79
_GnomeCanvasWaveView::gain_src
void * gain_src
Definition: canvas-waveview.h:88
_GnomeCanvasWaveViewCacheEntry
Definition: canvas-waveview.h:49
_GnomeCanvasWaveView::clip_color
uint32_t clip_color
Definition: canvas-waveview.h:109
alt_log_meter
static float alt_log_meter(float power)
Definition: logmeter.h:31
_GnomeCanvasWaveView::x
double x
Definition: canvas-waveview.h:104
_GnomeCanvasWaveViewCacheEntry::max
float max
Definition: canvas-waveview.h:52
_GnomeCanvasWaveView::wave_b
unsigned char wave_b
Definition: canvas-waveview.h:127
_GnomeCanvasWaveView::rectified
char rectified
Definition: canvas-waveview.h:114
gnome_canvas_waveview_set_channel
static void gnome_canvas_waveview_set_channel(GnomeCanvasWaveView *, guint32)
Definition: canvas-waveview.c:704
_GnomeCanvasWaveViewCacheEntry::min
float min
Definition: canvas-waveview.h:51
_GnomeCanvasWaveView::data_src
void * data_src
Definition: canvas-waveview.h:82
_GnomeCanvasWaveViewCache::data_size
guint64 data_size
Definition: canvas-waveview.h:59
PAINT_VERTA
#define PAINT_VERTA(inbuf, colr, colg, colb, cola, ptx, pty0, pty1)
Definition: rgb_macros.h:222
_GnomeCanvasWaveView::clip_g
unsigned char clip_g
Definition: canvas-waveview.h:128
gnome_canvas_waveview_flat_render
static void gnome_canvas_waveview_flat_render(GnomeCanvasItem *item, GnomeCanvasBuf *buf)
Definition: canvas-waveview.c:1654
gnome_canvas_waveview_ensure_cache
static guint32 gnome_canvas_waveview_ensure_cache(GnomeCanvasWaveView *waveview, gulong start_sample, gulong end_sample)
Definition: canvas-waveview.c:409
waveview_sourcefile_length_function_t
gulong(* waveview_sourcefile_length_function_t)(void *, double)
Definition: canvas-waveview.h:70
_GnomeCanvasWaveView::bbox_lrx
int32_t bbox_lrx
Definition: canvas-waveview.h:125
gnome_canvas_waveview_gradient_render
static void gnome_canvas_waveview_gradient_render(GnomeCanvasItem *item, GnomeCanvasBuf *buf)
Definition: canvas-waveview.c:1106
_GnomeCanvasWaveView::sourcefile_length_function
waveview_sourcefile_length_function_t sourcefile_length_function
Definition: canvas-waveview.h:86
_GnomeCanvasWaveView::fill_r
unsigned char fill_r
Definition: canvas-waveview.h:129
rgb_macros.h
gnome_canvas_waveview_bounds
static void gnome_canvas_waveview_bounds(GnomeCanvasItem *item, double *x1, double *y1, double *x2, double *y2)
Definition: canvas-waveview.c:2411
_GnomeCanvasWaveView::half_height
double half_height
Definition: canvas-waveview.h:107
_GnomeCanvasWaveView::screen_width
gint screen_width
Definition: canvas-waveview.h:80
MIN
#define MIN(a, b)
Definition: session_ltc.cc:45
waveview_peak_function_t
void(* waveview_peak_function_t)(void *, gulong, gulong, gulong, gpointer, guint32, double)
Definition: canvas-waveview.h:72
_GnomeCanvasWaveView::cache
GnomeCanvasWaveViewCache * cache
Definition: canvas-waveview.h:78
_GnomeCanvasWaveView::height
double height
Definition: canvas-waveview.h:106
PAINT_DOTA
#define PAINT_DOTA(inbuf, colr, colg, colb, cola, ptx, pty)
Definition: rgb_macros.h:115
_GnomeCanvasWaveView::reload_cache_in_render
int32_t reload_cache_in_render
Definition: canvas-waveview.h:132
_GnomeCanvasWaveView::channel
guint32 channel
Definition: canvas-waveview.h:83
_GnomeCanvasWaveView::gain_curve_function
waveview_gain_curve_function_t gain_curve_function
Definition: canvas-waveview.h:87
gnome_canvas_waveview_class_init
static void gnome_canvas_waveview_class_init(GnomeCanvasWaveViewClass *class)
Definition: canvas-waveview.c:156
_GnomeCanvasWaveView::wave_a
unsigned char wave_a
Definition: canvas-waveview.h:127
_GnomeCanvasWaveView::bbox_ulx
int32_t bbox_ulx
Definition: canvas-waveview.h:123
gnome_canvas_waveview_draw
static void gnome_canvas_waveview_draw(GnomeCanvasItem *item, GdkDrawable *drawable, int x, int y, int w, int h)
Definition: canvas-waveview.c:2197
_GnomeCanvasWaveView::fill_color
uint32_t fill_color
Definition: canvas-waveview.h:111
_GnomeCanvasWaveView::zero_color
uint32_t zero_color
Definition: canvas-waveview.h:110
gnome_canvas_waveview_get_property
static void gnome_canvas_waveview_get_property(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
Definition: canvas-waveview.c:943
_GnomeCanvasWaveViewClass
Definition: canvas-waveview.h:135
_GnomeCanvasWaveView::fill_b
unsigned char fill_b
Definition: canvas-waveview.h:129
Generated on Sun May 24 2015 12:15:02 for ardour by   doxygen 1.8.8