/*
- Copyright (C) 2000-2002 Paul Davis
+ Copyright (C) 2000-2002 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
#include <string.h>
#include <limits.h>
-#include <ardour/dB.h>
+#include "ardour/dB.h"
#include "logmeter.h"
#include "canvas-waveview.h"
static void gnome_canvas_waveview_set_channel (GnomeCanvasWaveView *,
guint32);
-static gint32 gnome_canvas_waveview_ensure_cache (GnomeCanvasWaveView *waveview,
+static guint32 gnome_canvas_waveview_ensure_cache (GnomeCanvasWaveView *waveview,
gulong start_sample,
gulong end_sample);
PROP_DATA_SRC,
g_param_spec_pointer ("data_src", NULL, NULL,
(G_PARAM_READABLE | G_PARAM_WRITABLE)));
-
+
g_object_class_install_property
(gobject_class,
PROP_CHANNEL,
g_param_spec_uint ("channel", NULL, NULL,
0, G_MAXUINT, 0,
(G_PARAM_READABLE | G_PARAM_WRITABLE)));
-
+
g_object_class_install_property
(gobject_class,
PROP_LENGTH_FUNCTION,
g_param_spec_pointer ("length_function", NULL, NULL,
(G_PARAM_READABLE | G_PARAM_WRITABLE)));
-
+
g_object_class_install_property
(gobject_class,
PROP_SOURCEFILE_LENGTH_FUNCTION,
g_param_spec_pointer ("sourcefile_length_function", NULL, NULL,
(G_PARAM_READABLE | G_PARAM_WRITABLE)));
-
+
g_object_class_install_property
(gobject_class,
PROP_PEAK_FUNCTION,
g_param_spec_pointer ("peak_function", NULL, NULL,
(G_PARAM_READABLE | G_PARAM_WRITABLE)));
-
+
g_object_class_install_property
(gobject_class,
PROP_GAIN_FUNCTION,
g_param_spec_pointer ("gain_function", NULL, NULL,
(G_PARAM_READABLE | G_PARAM_WRITABLE)));
-
+
g_object_class_install_property
(gobject_class,
PROP_GAIN_SRC,
g_param_spec_pointer ("gain_src", NULL, NULL,
(G_PARAM_READABLE | G_PARAM_WRITABLE)));
-
+
g_object_class_install_property
(gobject_class,
PROP_CACHE,
g_param_spec_pointer ("cache", NULL, NULL,
(G_PARAM_READABLE | G_PARAM_WRITABLE)));
-
+
g_object_class_install_property
(gobject_class,
PROP_CACHE_UPDATER,
g_param_spec_boolean ("cache_updater", NULL, NULL,
FALSE,
(G_PARAM_READABLE | G_PARAM_WRITABLE)));
-
+
g_object_class_install_property
(gobject_class,
PROP_SAMPLES_PER_UNIT,
g_param_spec_double ("samples_per_unit", NULL, NULL,
0.0, G_MAXDOUBLE, 0.0,
(G_PARAM_READABLE | G_PARAM_WRITABLE)));
-
+
g_object_class_install_property
(gobject_class,
PROP_AMPLITUDE_ABOVE_AXIS,
g_param_spec_double ("amplitude_above_axis", NULL, NULL,
0.0, G_MAXDOUBLE, 0.0,
(G_PARAM_READABLE | G_PARAM_WRITABLE)));
-
+
g_object_class_install_property
(gobject_class,
PROP_X,
g_param_spec_double ("x", NULL, NULL,
0.0, G_MAXDOUBLE, 0.0,
(G_PARAM_READABLE | G_PARAM_WRITABLE)));
-
+
g_object_class_install_property
(gobject_class,
PROP_Y,
g_param_spec_double ("y", NULL, NULL,
0.0, G_MAXDOUBLE, 0.0,
(G_PARAM_READABLE | G_PARAM_WRITABLE)));
-
+
g_object_class_install_property
(gobject_class,
PROP_HEIGHT,
g_param_spec_double ("height", NULL, NULL,
0.0, G_MAXDOUBLE, 0.0,
(G_PARAM_READABLE | G_PARAM_WRITABLE)));
-
+
g_object_class_install_property
(gobject_class,
PROP_WAVE_COLOR,
g_param_spec_uint ("wave_color", NULL, NULL,
0, G_MAXUINT, 0,
(G_PARAM_READABLE | G_PARAM_WRITABLE)));
-
+
g_object_class_install_property
(gobject_class,
PROP_CLIP_COLOR,
g_param_spec_uint ("clip_color", NULL, NULL,
0, G_MAXUINT, 0,
(G_PARAM_READABLE | G_PARAM_WRITABLE)));
-
+
g_object_class_install_property
(gobject_class,
PROP_ZERO_COLOR,
g_param_spec_boolean ("filled", NULL, NULL,
FALSE,
(G_PARAM_READABLE | G_PARAM_WRITABLE)));
-
+
g_object_class_install_property
(gobject_class,
PROP_RECTIFIED,
g_param_spec_boolean ("logscaled", NULL, NULL,
FALSE,
(G_PARAM_READABLE | G_PARAM_WRITABLE)));
-
+
g_object_class_install_property
(gobject_class,
PROP_REGION_START,
g_param_spec_uint ("region_start", NULL, NULL,
0, G_MAXUINT, 0,
(G_PARAM_READABLE | G_PARAM_WRITABLE)));
-
+
object_class->destroy = gnome_canvas_waveview_destroy;
-
+
item_class->update = gnome_canvas_waveview_update;
item_class->bounds = gnome_canvas_waveview_bounds;
item_class->point = gnome_canvas_waveview_point;
#define DEBUG_CACHE 0
#undef CACHE_MEMMOVE_OPTIMIZATION
-static gint32
+/** @return cache index of start_sample within the cache */
+static guint32
gnome_canvas_waveview_ensure_cache (GnomeCanvasWaveView *waveview, gulong start_sample, gulong end_sample)
{
gulong required_cache_entries;
#if DEBUG_CACHE
// printf("waveview->region_start == %lu\n",waveview->region_start);
// c_stacktrace ();
- printf ("\n\n=> 0x%x cache @ 0x%x range: %lu - %lu request: %lu - %lu (%lu frames)\n",
+ printf ("\n\n=> 0x%x cache @ 0x%x range: %lu - %lu request: %lu - %lu (%lu frames)\n",
waveview, cache,
cache->start, cache->end,
start_sample, end_sample, end_sample - start_sample);
#endif
-
+
if (cache->start <= start_sample && cache->end >= end_sample) {
#if DEBUG_CACHE
// printf ("0x%x: cache hit for %lu-%lu (cache holds: %lu-%lu\n",
}
/* make sure the cache is at least twice as wide as the screen width, and put the start sample
- in the middle, ensuring that we cover the end_sample.
+ in the middle, ensuring that we cover the end_sample.
*/
/* Note the assumption that we have a 1:1 units:pixel ratio for the canvas. Its everywhere ... */
-
+
half_width = (gulong) floor ((waveview->screen_width * waveview->samples_per_unit)/2.0 + 0.5);
-
+
if (start_sample < half_width) {
new_cache_start = 0;
} else {
}
#if DEBUG_CACHE
- fprintf (stderr, "AVAILABLE FRAMES = %lu of %lu, start = %lu, sstart = %lu, cstart = %lu\n",
+ fprintf (stderr, "AVAILABLE FRAMES = %lu of %lu, start = %lu, sstart = %lu, cstart = %lu\n",
rf3, waveview->sourcefile_length_function (waveview->data_src, waveview->samples_per_unit),
waveview->region_start, start_sample, new_cache_start);
#endif
ostart = new_cache_start;
#ifdef CACHE_MEMMOVE_OPTIMIZATION
-
+
/* data is not entirely in the cache, so go fetch it, making sure to fill the cache */
/* some of the required cache entries are in the cache, but in the wrong
*/
if (cache->start < new_cache_start && new_cache_start < cache->end) {
-
- /* case one: the common area is at the end of the existing cache. move it
+
+ /* case one: the common area is at the end of the existing cache. move it
to the beginning of the cache, and set up to refill whatever remains.
-
-
+
+
wv->cache_start wv->cache_end
|-------------------------------------------------------| cache
|--------------------------------| requested
<------------------->
"present"
- new_cache_start new_cache_end
+ new_cache_start new_cache_end
*/
-
+
present_frames = cache->end - new_cache_start;
present_entries = (gulong) floor (present_frames / waveview->samples_per_unit);
-#if DEBUG_CACHE
+#if DEBUG_CACHE
fprintf (stderr, "existing material at end of current cache, move to start of new cache\n"
"\tcopy from %lu to start\n", cache->data_size - present_entries);
#endif
memmove (&cache->data[0],
&cache->data[cache->data_size - present_entries],
present_entries * sizeof (GnomeCanvasWaveViewCacheEntry));
-
+
#if DEBUG_CACHE
fprintf (stderr, "satisfied %lu of %lu frames, offset = %lu, will start at %lu (ptr = 0x%x)\n",
present_frames, required_frames, present_entries, new_cache_start + present_entries,
} else if (new_cache_end > cache->start && new_cache_end < cache->end) {
- /* case two: the common area lives at the beginning of the existing cache.
-
+ /* case two: the common area lives at the beginning of the existing cache.
+
wv->cache_start wv->cache_end
|-----------------------------------------------------|
|--------------------------------|
new_cache_start new_cache_end
*/
-
+
present_frames = new_cache_end - cache->start;
present_entries = (gulong) floor (present_frames / waveview->samples_per_unit);
memmove (&cache->data[cache->data_size - present_entries],
&cache->data[0],
present_entries * sizeof (GnomeCanvasWaveViewCacheEntry));
-
-#if DEBUG_CACHE
+
+#if DEBUG_CACHE
fprintf (stderr, "existing material at start of current cache, move to start of end cache\n");
#endif
offset = 0;
required_frames -= present_frames;
-
+
} else {
copied = 0;
offset = 0;
waveview->peak_function (waveview->data_src, npeaks, new_cache_start, required_frames, cache->data + offset, waveview->channel,waveview->samples_per_unit);
/* take into account any copied peaks */
-
+
npeaks += copied;
} else {
npeaks = copied;
}
free (gain);
-
+
}
/* do optional log scaling. this implementation is not particularly efficient */
-
+
if (waveview->logscaled) {
guint32 n;
GnomeCanvasWaveViewCacheEntry* buf = cache->data;
-
+
for (n = 0; n < cache->data_size; ++n) {
if (buf[n].max > 0.0f) {
- buf[n].max = alt_log_meter(coefficient_to_dB(buf[n].max));
+ buf[n].max = alt_log_meter(fast_coefficient_to_dB(buf[n].max));
} else if (buf[n].max < 0.0f) {
- buf[n].max = -alt_log_meter(coefficient_to_dB(-buf[n].max));
+ buf[n].max = -alt_log_meter(fast_coefficient_to_dB(-buf[n].max));
}
-
+
if (buf[n].min > 0.0f) {
- buf[n].min = alt_log_meter(coefficient_to_dB(buf[n].min));
+ buf[n].min = alt_log_meter(fast_coefficient_to_dB(buf[n].min));
} else if (buf[n].min < 0.0f) {
- buf[n].min = -alt_log_meter(coefficient_to_dB(-buf[n].min));
+ buf[n].min = -alt_log_meter(fast_coefficient_to_dB(-buf[n].min));
}
}
}
out:
#if DEBUG_CACHE
- fprintf (stderr, "return cache index = %d\n",
- (gint32) floor ((((double) (start_sample - cache->start)) / waveview->samples_per_unit) + 0.5));
+ fprintf (stderr, "return cache index = %d\n",
+ (guint32) floor ((((double) (start_sample - cache->start)) / waveview->samples_per_unit) + 0.5));
#endif
- return (gint32) floor ((((double) (start_sample - cache->start)) / waveview->samples_per_unit) + 0.5);
+ return (guint32) floor ((((double) (start_sample - cache->start)) / waveview->samples_per_unit) + 0.5);
}
waveview->reload_cache_in_render = TRUE;
return;
}
-
+
waveview->cache->start = 0;
waveview->cache->end = 0;
}
if (waveview->channel == chan) {
return;
}
-
+
waveview->channel = chan;
}
-static void
+static void
gnome_canvas_waveview_reset_bounds (GnomeCanvasItem *item)
{
gnome_canvas_update_bbox (item, Ix1, Iy1, Ix2, Iy2);
}
-/*
- * CANVAS CALLBACKS
+/*
+ * CANVAS CALLBACKS
*/
static void
GParamSpec *pspec)
{
+ (void) pspec;
+
GnomeCanvasItem *item;
GnomeCanvasWaveView *waveview;
int redraw = FALSE;
waveview->length_function = g_value_get_pointer(value);
redraw = TRUE;
break;
+
case PROP_SOURCEFILE_LENGTH_FUNCTION:
waveview->sourcefile_length_function = g_value_get_pointer(value);
redraw = TRUE;
}
static void
-gnome_canvas_waveview_get_property (GObject *object,
- guint prop_id,
- GValue *value,
- GParamSpec *pspec)
+gnome_canvas_waveview_get_property (
+ GObject *object,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec)
{
-
-
+
+
g_return_if_fail (object != NULL);
- g_return_if_fail (GNOME_IS_CANVAS_WAVEVIEW (object));
+ g_return_if_fail (GNOME_IS_CANVAS_WAVEVIEW (object));
GnomeCanvasWaveView *waveview = GNOME_CANVAS_WAVEVIEW (object);
switch (prop_id) {
case PROP_DATA_SRC:
- g_value_set_pointer(value, waveview->data_src);
+ g_value_set_pointer(value, waveview->data_src);
break;
case PROP_CHANNEL:
- g_value_set_uint(value, waveview->channel);
+ g_value_set_uint(value, waveview->channel);
break;
case PROP_LENGTH_FUNCTION:
- g_value_set_pointer(value, waveview->length_function);
+ g_value_set_pointer(value, waveview->length_function);
break;
case PROP_SOURCEFILE_LENGTH_FUNCTION:
- g_value_set_pointer(value, waveview->sourcefile_length_function);
+ g_value_set_pointer(value, waveview->sourcefile_length_function);
break;
case PROP_PEAK_FUNCTION:
- g_value_set_pointer(value, waveview->peak_function);
+ g_value_set_pointer(value, waveview->peak_function);
break;
case PROP_GAIN_FUNCTION:
- g_value_set_pointer(value, waveview->gain_curve_function);
+ g_value_set_pointer(value, waveview->gain_curve_function);
break;
case PROP_GAIN_SRC:
- g_value_set_pointer(value, waveview->gain_src);
+ g_value_set_pointer(value, waveview->gain_src);
break;
case PROP_CACHE:
- g_value_set_pointer(value, waveview->cache);
+ g_value_set_pointer(value, waveview->cache);
break;
case PROP_CACHE_UPDATER:
- g_value_set_boolean(value, waveview->cache_updater);
+ g_value_set_boolean(value, waveview->cache_updater);
break;
case PROP_SAMPLES_PER_UNIT:
- g_value_set_double(value, waveview->samples_per_unit);
+ g_value_set_double(value, waveview->samples_per_unit);
break;
case PROP_AMPLITUDE_ABOVE_AXIS:
- g_value_set_double(value, waveview->amplitude_above_axis);
+ g_value_set_double(value, waveview->amplitude_above_axis);
break;
case PROP_X:
&waveview->fill_a);
// check_cache (waveview, "end of update");
-}
+}
static void
gnome_canvas_waveview_render (GnomeCanvasItem *item,
gulong s1, s2;
int clip_length = 0;
int pymin, pymax;
- int cache_index;
+ guint cache_index;
double half_height;
- int x, end, begin;
- int zbegin, zend;
+ int x;
char rectify;
waveview = GNOME_CANVAS_WAVEVIEW (item);
buf->is_bg = FALSE;
}
- begin = MAX(waveview->bbox_ulx, buf->rect.x0);
+ /* a "unit" means a pixel */
- if (begin == waveview->bbox_ulx) {
- zbegin = begin + 1;
- } else {
- zbegin = begin;
- }
+ /* begin: render start x (units) */
+ int const begin = MAX (waveview->bbox_ulx, buf->rect.x0);
- if (waveview->bbox_lrx >= 0) {
- end = MIN(waveview->bbox_lrx,buf->rect.x1);
- } else {
- end = buf->rect.x1;
- }
+ /* zbegin: start x for zero line (units) */
+ int const zbegin = (begin == waveview->bbox_ulx) ? (begin + 1) : begin;
- if (end == waveview->bbox_lrx) {
- zend = end - 1;
- } else {
- zend = end;
- }
+ /* end: render end x (units) */
+ int const end = (waveview->bbox_lrx >= 0) ? MIN (waveview->bbox_lrx,buf->rect.x1) : buf->rect.x1;
+
+ /* zend: end x for zero-line (units) */
+ int const zend = (end == waveview->bbox_lrx) ? (end - 1) : end;
if (begin == end) {
return;
}
- s1 = floor ((begin - waveview->bbox_ulx) * waveview->samples_per_unit) ;
+ /* s1: start sample
+ s2: end sample
+ */
+
+ s1 = floor ((begin - waveview->bbox_ulx) * waveview->samples_per_unit);
// fprintf (stderr, "0x%x begins at sample %f\n", waveview, waveview->bbox_ulx * waveview->samples_per_unit);
// check_cache (waveview, "post-ensure");
/* don't rectify at single-sample zoom */
- if(waveview->rectified && waveview->samples_per_unit > 1) {
+ if (waveview->rectified && waveview->samples_per_unit > 1) {
rectify = TRUE;
}
else {
clip_length = MIN(5,(waveview->height/4));
- /*
+ /*
Now draw each line, clipping it appropriately. The clipping
is done by the macros PAINT_FOO().
*/
/* this makes it slightly easier to comprehend whats going on */
#define origin half_height
- if(waveview->filled && !rectify) {
+ if (waveview->filled && !rectify) {
int prev_pymin = 1;
int prev_pymax = 0;
int last_pymin = 1;
int next_clip_max = 0;
int next_clip_min = 0;
- if(s1 < waveview->samples_per_unit) {
+ if (s1 < waveview->samples_per_unit) {
/* we haven't got a prev vars to compare with, so outline the whole line here */
prev_pymax = (int) rint ((item->y1 + origin) * item->canvas->pixels_per_unit);
prev_pymin = prev_pymax;
* Compute the variables outside the rendering rect
*/
if(prev_pymax != prev_pymin) {
+
prev_pymax = (int) rint ((item->y1 + origin - MIN(waveview->cache->data[cache_index].max, 1.0) * half_height) * item->canvas->pixels_per_unit);
prev_pymin = (int) rint ((item->y1 + origin - MAX(waveview->cache->data[cache_index].min, -1.0) * half_height) * item->canvas->pixels_per_unit);
++cache_index;
}
if(last_pymax != last_pymin) {
/* take the index of one sample right of what we render */
- int index = cache_index + (end - begin);
-
- last_pymax = (int) rint ((item->y1 + origin - MIN(waveview->cache->data[index].max, 1.0) * half_height) * item->canvas->pixels_per_unit);
- last_pymin = (int) rint ((item->y1 + origin - MAX(waveview->cache->data[index].min, -1.0) * half_height) * item->canvas->pixels_per_unit);
+ guint index = cache_index + (end - begin);
+
+ if (index >= waveview->cache->data_size) {
+
+ /* the data we want is off the end of the cache, which must mean its beyond
+ the end of the region's source; hence the peak values are 0 */
+ last_pymax = (int) rint ((item->y1 + origin) * item->canvas->pixels_per_unit);
+ last_pymin = (int) rint ((item->y1 + origin) * item->canvas->pixels_per_unit);
+
+ } else {
+
+ last_pymax = (int) rint ((item->y1 + origin - MIN(waveview->cache->data[index].max, 1.0) * half_height) * item->canvas->pixels_per_unit);
+ last_pymin = (int) rint ((item->y1 + origin - MAX(waveview->cache->data[index].min, -1.0) * half_height) * item->canvas->pixels_per_unit);
+
+ }
+
}
- /*
+ /*
* initialize NEXT* variables for the first run, duplicated in the loop for speed
*/
max = waveview->cache->data[cache_index].max;
min = waveview->cache->data[cache_index].min;
-
+
if (max >= 1.0) {
max = 1.0;
next_clip_max = 1;
}
-
+
if (min <= -1.0) {
min = -1.0;
next_clip_min = 1;
}
-
+
max *= half_height;
min *= half_height;
-
+
next_pymax = (int) rint ((item->y1 + origin - max) * item->canvas->pixels_per_unit);
next_pymin = (int) rint ((item->y1 + origin - min) * item->canvas->pixels_per_unit);
else {
++cache_index;
- max = waveview->cache->data[cache_index].max;
- min = waveview->cache->data[cache_index].min;
+ if (cache_index < waveview->cache->data_size) {
+ max = waveview->cache->data[cache_index].max;
+ min = waveview->cache->data[cache_index].min;
+ } else {
+ max = min = 0;
+ }
next_clip_max = 0;
next_clip_min = 0;
max = 1.0;
next_clip_max = 1;
}
-
+
if (min <= -1.0) {
min = -1.0;
next_clip_min = 1;
max *= half_height;
min *= half_height;
-
+
next_pymax = (int) rint ((item->y1 + origin - max) * item->canvas->pixels_per_unit);
next_pymin = (int) rint ((item->y1 + origin - min) * item->canvas->pixels_per_unit);
}
-
+
/* render */
if (pymax == pymin) {
PAINT_DOTA(buf, waveview->wave_r, waveview->wave_g, waveview->wave_b, waveview->wave_a, x, pymin);
if (clip_max) {
PAINT_VERTA(buf, waveview->clip_r, waveview->clip_g, waveview->clip_b, waveview->clip_a, x, pymax, pymax+clip_length);
}
-
+
if (clip_min) {
PAINT_VERTA(buf, waveview->clip_r, waveview->clip_g, waveview->clip_b, waveview->clip_a, x, pymin-clip_length, pymin);
}
prev_pymax = pymax;
prev_pymin = pymin;
}
- }
- else if(waveview->filled && rectify) {
+
+ } else if (waveview->filled && rectify) {
+
int prev_pymax = -1;
int last_pymax = -1;
int next_pymax;
if(last_pymax < 0) {
/* take the index of one sample right of what we render */
int index = cache_index + (end - begin);
-
+
max = MIN(waveview->cache->data[index].max, 1.0);
min = MAX(waveview->cache->data[index].min, -1.0);
last_pymax = (int) rint ((item->y1 + waveview->height - max * waveview->height) * item->canvas->pixels_per_unit);
}
- /*
+ /*
* initialize NEXT* variables for the first run, duplicated in the loop for speed
*/
max = waveview->cache->data[cache_index].max;
min = waveview->cache->data[cache_index].min;
-
+
if (max >= 1.0) {
max = 1.0;
next_clip_max = 1;
}
-
+
if (min <= -1.0) {
min = -1.0;
next_clip_min = 1;
}
-
+
if (fabs (min) > fabs (max)) {
max = fabs (min);
- }
-
+ }
+
next_pymax = (int) rint ((item->y1 + waveview->height - max * waveview->height) * item->canvas->pixels_per_unit);
/*
max = waveview->cache->data[cache_index].max;
min = waveview->cache->data[cache_index].min;
-
+
if (max >= 1.0) {
max = 1.0;
next_clip_max = 1;
}
-
+
if (min <= -1.0) {
min = -1.0;
next_clip_min = 1;
}
-
+
if (fabs (min) > fabs (max)) {
max = fabs (min);
- }
-
+ }
+
next_pymax = (int) rint ((item->y1 + waveview->height - max * waveview->height) * item->canvas->pixels_per_unit);
}
-
+
/* render */
if (pymax == pymin) {
PAINT_DOTA(buf, waveview->wave_r, waveview->wave_g, waveview->wave_b, waveview->wave_a, x, pymin);
if (clip_max) {
PAINT_VERTA(buf, waveview->clip_r, waveview->clip_g, waveview->clip_b, waveview->clip_a, x, pymax, pymax+clip_length);
}
-
+
if (clip_min) {
PAINT_VERTA(buf, waveview->clip_r, waveview->clip_g, waveview->clip_b, waveview->clip_a, x, pymin-clip_length, pymin);
}
cache_index = gnome_canvas_waveview_ensure_cache (waveview, s1, s2);
for (x = begin; x < end; x++) {
-
+
double max, min;
int clip_max, clip_min;
-
+
clip_max = 0;
clip_min = 0;
-
+
max = waveview->cache->data[cache_index].max;
min = waveview->cache->data[cache_index].min;
-
+
if (max >= 1.0) {
max = 1.0;
clip_max = 1;
}
-
+
if (min <= -1.0) {
min = -1.0;
clip_min = 1;
}
-
+
if (rectify) {
-
+
if (fabs (min) > fabs (max)) {
max = fabs (min);
- }
-
+ }
+
max = max * waveview->height;
-
+
pymax = (int) rint ((item->y1 + waveview->height - max) * item->canvas->pixels_per_unit);
pymin = (int) rint ((item->y1 + waveview->height) * item->canvas->pixels_per_unit);
-
+
} else {
-
+
max = max * half_height;
min = min * half_height;
-
+
pymax = (int) rint ((item->y1 + origin - max) * item->canvas->pixels_per_unit);
pymin = (int) rint ((item->y1 + origin - min) * item->canvas->pixels_per_unit);
}
-
+
/* OK, now fill the RGB buffer at x=i with a line between pymin and pymax,
or, if samples_per_unit == 1, then a dot at each location.
*/
-
+
if (pymax == pymin) {
PAINT_DOTA(buf, waveview->wave_r, waveview->wave_g, waveview->wave_b, waveview->wave_a, x, pymin);
} else {
PAINT_VERTA(buf, waveview->wave_r, waveview->wave_g, waveview->wave_b, waveview->wave_a, x, pymax, pymin);
}
-
+
/* show clipped waveforms with small red lines */
-
+
if (clip_max) {
PAINT_VERTA(buf, waveview->clip_r, waveview->clip_g, waveview->clip_b, waveview->clip_a, x, pymax, pymax+clip_length);
}
-
+
if (clip_min) {
PAINT_VERTA(buf, waveview->clip_r, waveview->clip_g, waveview->clip_b, waveview->clip_a, x, pymin-clip_length, pymin);
}
/* presto, we're done */
-
+
cache_index++;
}
}
if (!waveview->rectified && waveview->zero_line) {
// Paint zeroline.
//PAINT_HORIZA(buf, waveview->zero_r, waveview->zero_g, waveview->zero_b, waveview->zero_a, begin, endi-1, origin );
-
+
unsigned char zero_r, zero_g, zero_b, zero_a;
UINT_TO_RGBA( waveview->zero_color, &zero_r, &zero_g, &zero_b, &zero_a );
int zeroline_y = (int) rint ((item->y1 + origin) * item->canvas->pixels_per_unit);
- PAINT_HORIZA(buf, zero_r, zero_g, zero_b, zero_a, zbegin, end, zeroline_y);
+ PAINT_HORIZA(buf, zero_r, zero_g, zero_b, zero_a, zbegin, zend, zeroline_y);
}
#undef origin
cairo_t* cr;
gulong s1, s2;
int cache_index;
- double zbegin, zend;
gboolean rectify;
- double n;
double origin;
double clip_length;
double xoff;
- double yoff;
+ double yoff = 0.0;
double ulx;
double uly;
double lrx;
if (x > waveview->bbox_ulx) {
ulx = x;
- zbegin = ulx;
} else {
ulx = waveview->bbox_ulx;
- zbegin = ulx + 1;
}
if (y > waveview->bbox_uly) {
if (x + width > waveview->bbox_lrx) {
lrx = waveview->bbox_lrx;
- zend = lrx - 1;
} else {
lrx = x + width;
- zend = lrx;
}
if (y + height > waveview->bbox_lry) {
uly -= y;
lrx -= x;
lry -= y;
- zbegin -= x;
- zend -= x;
/* don't rectify at single-sample zoom */
if(waveview->rectified && waveview->samples_per_unit > 1.0) {
printf ("%p r (%d,%d)(%d,%d)[%d x %d] bbox (%d,%d)(%d,%d)[%d x %d]"
" draw (%.1f,%.1f)(%.1f,%.1f)[%.1f x %.1f] s= %lu..%lu\n",
waveview,
- x, y,
+ x, y,
x + width,
y + height,
width,
#endif
/* draw the top half */
-
+
for (xoff = ulx; xoff < lrx; xoff++) {
double max, min;
if (min <= -1.0) {
min = -1.0;
}
-
+
if (max >= 1.0) {
max = 1.0;
}
-
+
if (rectify) {
if (fabs (min) > fabs (max)) {
max = fabs (min);
- }
- }
-
+ }
+ }
+
yoff = origin - (waveview->half_height * max) + 0.5;
-
- if (n == ulx) {
+
+ if (xoff == ulx) {
+ /* first point */
cairo_move_to (cr, xoff+0.5, yoff);
} else {
cairo_line_to (cr, xoff+0.5, yoff);
}
/* from the final top point, move out of the clip zone */
-
+
cairo_line_to (cr, xoff + 10, yoff);
-
+
/* now draw the bottom half */
for (--xoff, --cache_index; xoff >= ulx; --xoff) {
/* from the final lower point, move out of the clip zone */
cairo_line_to (cr, xoff - 10, yoff);
-
+
/* close path to fill */
cairo_close_path (cr);
/* fill and stroke */
- cairo_set_source_rgba (cr,
- (waveview->fill_r/255.0),
- (waveview->fill_g/255.0),
- (waveview->fill_b/255.0),
+ cairo_set_source_rgba (cr,
+ (waveview->fill_r/255.0),
+ (waveview->fill_g/255.0),
+ (waveview->fill_b/255.0),
(waveview->fill_a/255.0));
cairo_fill_preserve (cr);
- cairo_set_source_rgba (cr,
- (waveview->wave_r/255.0),
- (waveview->wave_g/255.0),
- (waveview->wave_b/255.0),
+ cairo_set_source_rgba (cr,
+ (waveview->wave_r/255.0),
+ (waveview->wave_g/255.0),
+ (waveview->wave_b/255.0),
(waveview->wave_a/255.0));
cairo_stroke (cr);
cairo_line_to (cr, xoff, yoff1 + clip_length);
cairo_stroke (cr);
}
-
+
if (clip_min) {
cairo_move_to (cr, xoff, yoff2);
cairo_line_to (cr, xoff, yoff2 - clip_length);
cairo_stroke (cr);
}
-
+
#endif
static void
gnome_canvas_item_i2w (item, &x, &y);
gnome_canvas_w2c_d (GNOME_CANVAS(item->canvas), x, y, &c, &d);
printf ("item bounds now (%g,%g),(%g,%g)\n", a, b, c, d);
-#endif
+#endif
}
static double
gnome_canvas_waveview_point (GnomeCanvasItem *item, double x, double y, int cx, int cy, GnomeCanvasItem **actual_item)
{
- /* XXX for now, point is never inside the wave
+ (void) item;
+ (void) x;
+ (void) y;
+ (void) cx;
+ (void) cy;
+ (void) actual_item;
+
+ /* XXX for now, point is never inside the wave
GnomeCanvasWaveView *waveview;
double x1, y1, x2, y2;
double dx, dy;
gnome_canvas_waveview_bounds (item, &x1, &y1, &x2, &y2);
/* Is point inside rectangle */
-
+
if ((x >= x1) && (y >= y1) && (x <= x2) && (y <= y2)) {
return 0.0;
}
projects / ardour.git / blobdiff