ardour/livetrax
13
0
Fork 0
Code
96ca08b925
livetrax/gtk2_ardour/canvas-waveview.c
David Robillard 99904735e0 Merged with trunk R1612. 
git-svn-id: svn://localhost/ardour2/branches/midi@1614 d708f5d6-7413-0410-9779-e7cbd77b26cf
2007-03-18 06:07:08 +00:00

1233 lines
32 KiB
C
Raw Blame History

/*
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
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
$Id$
*/
#include <stdio.h>
#include <math.h>
#include <libgnomecanvas/libgnomecanvas.h>
#include <string.h>
#include <limits.h>
#include <ardour/dB.h>
#include "logmeter.h"
#include "canvas-waveview.h"
#include "rgb_macros.h"
extern void c_stacktrace();
enum {
PROP_0,
PROP_DATA_SRC,
PROP_CHANNEL,
PROP_LENGTH_FUNCTION,
PROP_SOURCEFILE_LENGTH_FUNCTION,
PROP_PEAK_FUNCTION,
PROP_GAIN_FUNCTION,
PROP_GAIN_SRC,
PROP_CACHE,
PROP_CACHE_UPDATER,
PROP_SAMPLES_PER_UNIT,
PROP_AMPLITUDE_ABOVE_AXIS,
PROP_X,
PROP_Y,
PROP_HEIGHT,
PROP_WAVE_COLOR,
PROP_RECTIFIED,
PROP_REGION_START,
PROP_LOGSCALED,
};
static void gnome_canvas_waveview_class_init (GnomeCanvasWaveViewClass *class);
static void gnome_canvas_waveview_init (GnomeCanvasWaveView *waveview);
static void gnome_canvas_waveview_destroy (GtkObject *object);
static void gnome_canvas_waveview_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec);
static void gnome_canvas_waveview_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec);
static void gnome_canvas_waveview_update (GnomeCanvasItem *item,
double *affine,
ArtSVP *clip_path,
int flags);
static void gnome_canvas_waveview_bounds (GnomeCanvasItem *item,
double *x1,
double *y1,
double *x2,
double *y2);
static double gnome_canvas_waveview_point (GnomeCanvasItem *item,
double x,
double y,
int cx,
int cy,
GnomeCanvasItem **actual_item);
static void gnome_canvas_waveview_render (GnomeCanvasItem *item,
GnomeCanvasBuf *buf);
static void gnome_canvas_waveview_draw (GnomeCanvasItem *item,
GdkDrawable *drawable,
int x,
int y,
int w,
int h);
static void gnome_canvas_waveview_set_data_src (GnomeCanvasWaveView *,
void *);
static void gnome_canvas_waveview_set_channel (GnomeCanvasWaveView *,
guint32);
static gint32 gnome_canvas_waveview_ensure_cache (GnomeCanvasWaveView *waveview,
gulong start_sample,
gulong end_sample);
static GnomeCanvasItemClass *parent_class;
GType
gnome_canvas_waveview_get_type (void)
{
static GType waveview_type;
if (!waveview_type) {
static const GTypeInfo object_info = {
sizeof (GnomeCanvasWaveViewClass),
(GBaseInitFunc) NULL,
(GBaseFinalizeFunc) NULL,
(GClassInitFunc) gnome_canvas_waveview_class_init,
(GClassFinalizeFunc) NULL,
NULL, /* class_data */
sizeof (GnomeCanvasWaveView),
0, /* n_preallocs */
(GInstanceInitFunc) gnome_canvas_waveview_init,
NULL /* value_table */
};
waveview_type = g_type_register_static (GNOME_TYPE_CANVAS_ITEM, "GnomeCanvasWaveView",
&object_info, 0);
}
return waveview_type;
}
static void
gnome_canvas_waveview_class_init (GnomeCanvasWaveViewClass *class)
{
GObjectClass *gobject_class;
GtkObjectClass *object_class;
GnomeCanvasItemClass *item_class;
gobject_class = (GObjectClass *) class;
object_class = (GtkObjectClass *) class;
item_class = (GnomeCanvasItemClass *) class;
parent_class = g_type_class_peek_parent (class);
gobject_class->set_property = gnome_canvas_waveview_set_property;
gobject_class->get_property = gnome_canvas_waveview_get_property;
g_object_class_install_property
(gobject_class,
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_RECTIFIED,
g_param_spec_boolean ("rectified", NULL, NULL,
FALSE,
(G_PARAM_READABLE | G_PARAM_WRITABLE)));
g_object_class_install_property
(gobject_class,
PROP_LOGSCALED,
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;
item_class->render = gnome_canvas_waveview_render;
item_class->draw = gnome_canvas_waveview_draw;
}
GnomeCanvasWaveViewCache*
gnome_canvas_waveview_cache_new ()
{
GnomeCanvasWaveViewCache *c;
c = g_malloc (sizeof (GnomeCanvasWaveViewCache));
c->allocated = 2048;
c->data = g_malloc (sizeof (GnomeCanvasWaveViewCacheEntry) * c->allocated);
c->data_size = 0;
c->start = 0;
c->end = 0;
return c;
}
void
gnome_canvas_waveview_cache_destroy (GnomeCanvasWaveViewCache* cache)
{
g_free (cache->data);
g_free (cache);
}
static void
gnome_canvas_waveview_init (GnomeCanvasWaveView *waveview)
{
waveview->x = 0.0;
waveview->y = 0.0;
waveview->cache = 0;
waveview->cache_updater = FALSE;
waveview->data_src = NULL;
waveview->channel = 0;
waveview->peak_function = NULL;
waveview->length_function = NULL;
waveview->sourcefile_length_function = NULL;
waveview->gain_curve_function = NULL;
waveview->gain_src = NULL;
waveview->rectified = FALSE;
waveview->logscaled = FALSE;
waveview->region_start = 0;
waveview->samples_per_unit = 1.0;
waveview->amplitude_above_axis = 1.0;
waveview->height = 100.0;
waveview->screen_width = gdk_screen_width ();
waveview->reload_cache_in_render = FALSE;
waveview->wave_color = RGBA_TO_UINT(44,35,126,255);
}
static void
gnome_canvas_waveview_destroy (GtkObject *object)
{
GnomeCanvasWaveView *waveview;
g_return_if_fail (object != NULL);
g_return_if_fail (GNOME_IS_CANVAS_WAVEVIEW (object));
waveview = GNOME_CANVAS_WAVEVIEW (object);
if (GTK_OBJECT_CLASS (parent_class)->destroy)
(* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
}
#define DEBUG_CACHE 0
#undef CACHE_MEMMOVE_OPTIMIZATION
static gint32
gnome_canvas_waveview_ensure_cache (GnomeCanvasWaveView *waveview, gulong start_sample, gulong end_sample)
{
gulong required_cache_entries;
gulong rf1, rf2,rf3, required_frames;
gulong new_cache_start, new_cache_end;
gulong half_width;
gulong npeaks;
gulong offset;
gulong ostart;
gulong copied;
GnomeCanvasWaveViewCache *cache;
float* gain;
#ifdef CACHE_MEMMOVE_OPTIMIZATION
gulong present_frames;
gulong present_entries;
#endif
cache = waveview->cache;
start_sample = start_sample + waveview->region_start;
end_sample = end_sample + waveview->region_start;
#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",
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",
// waveview, start_sample, end_sample, cache->start, cache->end);
#endif
goto out;
}
/* 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.
*/
/* 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 {
new_cache_start = start_sample - half_width;
}
/* figure out how many frames we want */
rf1 = end_sample - start_sample + 1;
rf2 = (gulong) floor ((waveview->screen_width * waveview->samples_per_unit * 2.0f));
required_frames = MAX(rf1,rf2);
/* but make sure it doesn't extend beyond the end of the source material */
rf3 = (gulong) (waveview->sourcefile_length_function (waveview->data_src, waveview->samples_per_unit)) + 1;
if (rf3 < new_cache_start) {
rf3 = 0;
} else {
rf3 -= new_cache_start;
}
#if DEBUG_CACHE
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
required_frames = MIN(required_frames,rf3);
new_cache_end = new_cache_start + required_frames - 1;
required_cache_entries = (gulong) floor (required_frames / waveview->samples_per_unit );
#if DEBUG_CACHE
fprintf (stderr, "new cache = %lu - %lu\n", new_cache_start, new_cache_end);
fprintf(stderr,"required_cach_entries = %lu, samples_per_unit = %f req frames = %lu\n",
required_cache_entries,waveview->samples_per_unit, required_frames);
#endif
if (required_cache_entries > cache->allocated) {
cache->data = g_realloc (cache->data, sizeof (GnomeCanvasWaveViewCacheEntry) * required_cache_entries);
cache->allocated = required_cache_entries;
// cache->start = 0;
// cache->end = 0;
}
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
locations. use memmove to fix this.
*/
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
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
*/
present_frames = cache->end - new_cache_start;
present_entries = (gulong) floor (present_frames / waveview->samples_per_unit);
#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,
cache->data + present_entries);
#endif
copied = present_entries;
offset = present_entries;
new_cache_start += present_frames;
required_frames -= present_frames;
} 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.
wv->cache_start wv->cache_end
|-----------------------------------------------------|
|--------------------------------|
<----------------->
"present"
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
fprintf (stderr, "existing material at start of current cache, move to start of end cache\n");
#endif
#if DEBUG_CACHE
fprintf (stderr, "satisfied %lu of %lu frames, offset = %lu, will start at %lu (ptr = 0x%x)\n",
present_entries, required_frames, present_entries, new_cache_start + present_entries,
cache->data + present_entries);
#endif
copied = present_entries;
offset = 0;
required_frames -= present_frames;
} else {
copied = 0;
offset = 0;
}
#else
copied = 0;
offset = 0;
#endif /* CACHE_MEMMOVE_OPTIMIZATION */
// fprintf(stderr,"length == %lu\n",waveview->length_function (waveview->data_src));
// required_frames = MIN (waveview->length_function (waveview->data_src) - new_cache_start, required_frames);
npeaks = (gulong) floor (required_frames / waveview->samples_per_unit);
required_frames = npeaks * waveview->samples_per_unit;
#if DEBUG_CACHE
printf ("requesting %lu/%f to cover %lu-%lu at %f spu (request was %lu-%lu) into cache + %lu\n",
required_frames, required_frames/waveview->samples_per_unit, new_cache_start, new_cache_end,
waveview->samples_per_unit, start_sample, end_sample, offset);
#endif
#if DEBUG_CACHE
// printf ("cache holds %lu entries, requesting %lu to cover %lu-%lu (request was %lu-%lu)\n",
// cache->data_size, npeaks, new_cache_start, new_cache_end,
// start_sample, end_sample);
#endif
if (required_frames) {
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;
}
if (npeaks < cache->allocated) {
#if DEBUG_CACHE
fprintf (stderr, "zero fill cache for %lu at %lu\n", cache->allocated - npeaks, npeaks);
#endif
memset (&cache->data[npeaks], 0, sizeof (GnomeCanvasWaveViewCacheEntry) * (cache->allocated - npeaks));
cache->data_size = npeaks;
} else {
cache->data_size = cache->allocated;
}
if (waveview->gain_curve_function) {
guint32 n;
gain = (float*) malloc (sizeof (float) * cache->data_size);
waveview->gain_curve_function (waveview->gain_src, new_cache_start, new_cache_end, gain, cache->data_size);
for (n = 0; n < cache->data_size; ++n) {
cache->data[n].min *= gain[n];
cache->data[n].max *= gain[n];
}
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));
} else if (buf[n].max < 0.0f) {
buf[n].max = -alt_log_meter(coefficient_to_dB(-buf[n].max));
}
if (buf[n].min > 0.0f) {
buf[n].min = alt_log_meter(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));
}
}
}
cache->start = ostart;
cache->end = new_cache_end;
out:
#if DEBUG_CACHE
fprintf (stderr, "return cache index = %d\n",
(gint32) 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);
}
void
gnome_canvas_waveview_set_data_src (GnomeCanvasWaveView *waveview, void *data_src)
{
if (waveview->cache_updater) {
if (waveview->data_src == data_src) {
waveview->reload_cache_in_render = TRUE;
return;
}
waveview->cache->start = 0;
waveview->cache->end = 0;
}
waveview->data_src = data_src;
}
void
gnome_canvas_waveview_set_channel (GnomeCanvasWaveView *waveview, guint32 chan)
{
if (waveview->channel == chan) {
return;
}
waveview->channel = chan;
}
static void
gnome_canvas_waveview_reset_bounds (GnomeCanvasItem *item)
{
double x1, x2, y1, y2;
ArtPoint i1, i2;
ArtPoint w1, w2;
int Ix1, Ix2, Iy1, Iy2;
double i2w[6];
gnome_canvas_waveview_bounds (item, &x1, &y1, &x2, &y2);
i1.x = x1;
i1.y = y1;
i2.x = x2;
i2.y = y2;
gnome_canvas_item_i2w_affine (item, i2w);
art_affine_point (&w1, &i1, i2w);
art_affine_point (&w2, &i2, i2w);
Ix1 = (int) rint(w1.x);
Ix2 = (int) rint(w2.x);
Iy1 = (int) rint(w1.y);
Iy2 = (int) rint(w2.y);
gnome_canvas_update_bbox (item, Ix1, Iy1, Ix2, Iy2);
}
/*
* CANVAS CALLBACKS
*/
static void
gnome_canvas_waveview_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
GnomeCanvasItem *item;
GnomeCanvasWaveView *waveview;
int redraw = FALSE;
int calc_bounds = FALSE;
g_return_if_fail (object != NULL);
g_return_if_fail (GNOME_IS_CANVAS_WAVEVIEW (object));
item = GNOME_CANVAS_ITEM (object);
waveview = GNOME_CANVAS_WAVEVIEW (object);
switch (prop_id) {
case PROP_DATA_SRC:
gnome_canvas_waveview_set_data_src (waveview, g_value_get_pointer(value));
redraw = TRUE;
break;
case PROP_CHANNEL:
gnome_canvas_waveview_set_channel (waveview, g_value_get_uint(value));
redraw = TRUE;
break;
case PROP_LENGTH_FUNCTION:
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;
break;
case PROP_PEAK_FUNCTION:
waveview->peak_function = g_value_get_pointer(value);
redraw = TRUE;
break;
case PROP_GAIN_FUNCTION:
waveview->gain_curve_function = g_value_get_pointer(value);
redraw = TRUE;
break;
case PROP_GAIN_SRC:
waveview->gain_src = g_value_get_pointer(value);
if (waveview->cache_updater) {
waveview->cache->start = 0;
waveview->cache->end = 0;
}
redraw = TRUE;
calc_bounds = TRUE;
break;
case PROP_CACHE:
waveview->cache = g_value_get_pointer(value);
redraw = TRUE;
break;
case PROP_CACHE_UPDATER:
waveview->cache_updater = g_value_get_boolean(value);
redraw = TRUE;
break;
case PROP_SAMPLES_PER_UNIT:
if ((waveview->samples_per_unit = g_value_get_double(value)) < 1.0) {
waveview->samples_per_unit = 1.0;
}
if (waveview->cache_updater) {
waveview->cache->start = 0;
waveview->cache->end = 0;
}
redraw = TRUE;
calc_bounds = TRUE;
break;
case PROP_AMPLITUDE_ABOVE_AXIS:
waveview->amplitude_above_axis = g_value_get_double(value);
redraw = TRUE;
break;
case PROP_X:
if (waveview->x != g_value_get_double (value)) {
waveview->x = g_value_get_double (value);
calc_bounds = TRUE;
}
break;
case PROP_Y:
if (waveview->y != g_value_get_double (value)) {
waveview->y = g_value_get_double (value);
calc_bounds = TRUE;
}
break;
case PROP_HEIGHT:
if (waveview->height != fabs (g_value_get_double (value))) {
waveview->height = fabs (g_value_get_double (value));
redraw = TRUE;
}
break;
case PROP_WAVE_COLOR:
if (waveview->wave_color != g_value_get_uint(value)) {
waveview->wave_color = g_value_get_uint(value);
redraw = TRUE;
}
break;
case PROP_RECTIFIED:
if (waveview->rectified != g_value_get_boolean(value)) {
waveview->rectified = g_value_get_boolean(value);
redraw = TRUE;
}
break;
case PROP_LOGSCALED:
if (waveview->logscaled != g_value_get_boolean(value)) {
waveview->logscaled = g_value_get_boolean(value);
if (waveview->cache_updater) {
waveview->cache->start = 0;
waveview->cache->end = 0;
}
redraw = TRUE;
calc_bounds = TRUE;
}
break;
case PROP_REGION_START:
waveview->region_start = g_value_get_uint(value);
redraw = TRUE;
calc_bounds = TRUE;
break;
default:
break;
}
if (calc_bounds) {
gnome_canvas_waveview_reset_bounds (item);
}
if (redraw) {
gnome_canvas_item_request_update (item);
}
}
static void
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));
GnomeCanvasWaveView *waveview = GNOME_CANVAS_WAVEVIEW (object);
switch (prop_id) {
case PROP_DATA_SRC:
g_value_set_pointer(value, waveview->data_src);
break;
case PROP_CHANNEL:
g_value_set_uint(value, waveview->channel);
break;
case PROP_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);
break;
case PROP_PEAK_FUNCTION:
g_value_set_pointer(value, waveview->peak_function);
break;
case PROP_GAIN_FUNCTION:
g_value_set_pointer(value, waveview->gain_curve_function);
break;
case PROP_GAIN_SRC:
g_value_set_pointer(value, waveview->gain_src);
break;
case PROP_CACHE:
g_value_set_pointer(value, waveview->cache);
break;
case PROP_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);
break;
case PROP_AMPLITUDE_ABOVE_AXIS:
g_value_set_double(value, waveview->amplitude_above_axis);
break;
case PROP_X:
g_value_set_double (value, waveview->x);
break;
case PROP_Y:
g_value_set_double (value, waveview->y);
break;
case PROP_HEIGHT:
g_value_set_double (value, waveview->height);
break;
case PROP_WAVE_COLOR:
g_value_set_uint (value, waveview->wave_color);
break;
case PROP_RECTIFIED:
g_value_set_boolean (value, waveview->rectified);
break;
case PROP_LOGSCALED:
g_value_set_boolean (value, waveview->logscaled);
break;
case PROP_REGION_START:
g_value_set_uint (value, waveview->region_start);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gnome_canvas_waveview_update (GnomeCanvasItem *item, double *affine, ArtSVP *clip_path, int flags)
{
GnomeCanvasWaveView *waveview;
double x, y;
waveview = GNOME_CANVAS_WAVEVIEW (item);
// check_cache (waveview, "start of update");
if (parent_class->update)
(* parent_class->update) (item, affine, clip_path, flags);
gnome_canvas_waveview_reset_bounds (item);
/* get the canvas coordinates of the view. Do NOT use affines
for this, because they do not round to the integer units used
by the canvas, resulting in subtle pixel-level errors later.
*/
x = waveview->x;
y = waveview->y;
gnome_canvas_item_i2w (item, &x, &y);
gnome_canvas_w2c (GNOME_CANVAS(item->canvas), x, y, &waveview->bbox_ulx, &waveview->bbox_uly);
waveview->samples = waveview->length_function (waveview->data_src);
x = waveview->x + (waveview->samples / waveview->samples_per_unit);
y = waveview->y + waveview->height;
gnome_canvas_item_i2w (item, &x, &y);
gnome_canvas_w2c (GNOME_CANVAS(item->canvas), x, y, &waveview->bbox_lrx, &waveview->bbox_lry);
/* cache the half-height and the end point in canvas units */
waveview->half_height = waveview->height / 2.0;
/* parse the color */
UINT_TO_RGBA (waveview->wave_color, &waveview->wave_r, &waveview->wave_g, &waveview->wave_b,
&waveview->wave_a);
// check_cache (waveview, "end of update");
}
static void
gnome_canvas_waveview_render (GnomeCanvasItem *item,
GnomeCanvasBuf *buf)
{
GnomeCanvasWaveView *waveview;
gulong s1, s2;
int clip_length = 0;
int pymin, pymax;
int cache_index;
double half_height;
int x, end, begin;
waveview = GNOME_CANVAS_WAVEVIEW (item);
// check_cache (waveview, "start of render");
if (parent_class->render) {
(*parent_class->render) (item, buf);
}
if (buf->is_bg) {
gnome_canvas_buf_ensure_buf (buf);
buf->is_bg = FALSE;
}
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;
}
if (begin == end) {
return;
}
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);
if (end == waveview->bbox_lrx) {
/* This avoids minor rounding errors when we have the
entire region visible.
*/
s2 = waveview->samples;
} else {
s2 = s1 + floor ((end - begin) * waveview->samples_per_unit);
}
#if 0
printf ("0x%x r (%d..%d)(%d..%d) bbox (%d..%d)(%d..%d)"
" b/e %d..%d s= %lu..%lu @ %f\n",
waveview,
buf->rect.x0,
buf->rect.x1,
buf->rect.y0,
buf->rect.y1,
waveview->bbox_ulx,
waveview->bbox_lrx,
waveview->bbox_uly,
waveview->bbox_lry,
begin, end, s1, s2,
waveview->samples_per_unit);
#endif
/* now ensure that the cache is full and properly
positioned.
*/
// check_cache (waveview, "pre-ensure");
if (waveview->cache_updater && waveview->reload_cache_in_render) {
waveview->cache->start = 0;
waveview->cache->end = 0;
waveview->reload_cache_in_render = FALSE;
}
cache_index = gnome_canvas_waveview_ensure_cache (waveview, s1, s2);
// check_cache (waveview, "post-ensure");
/*
Now draw each line, clipping it appropriately. The clipping
is done by the macros PAINT_FOO().
*/
half_height = waveview->half_height;
/* this makes it slightly easier to comprehend whats going on */
#define origin half_height
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;
}
/* don't rectify at single-sample zoom */
if (waveview->rectified && waveview->samples_per_unit > 1) {
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 || clip_min) {
clip_length = MIN(5,(waveview->height/4));
}
if (clip_max) {
PAINT_VERT(buf, 255, 0, 0, x, pymax, pymax+clip_length);
}
if (clip_min) {
PAINT_VERT(buf, 255, 0, 0, x, pymin-clip_length, pymin);
}
/* presto, we're done */
cache_index++;
}
#undef origin
}
static void
gnome_canvas_waveview_draw (GnomeCanvasItem *item,
GdkDrawable *drawable,
int x, int y,
int width, int height)
{
GnomeCanvasWaveView *waveview;
waveview = GNOME_CANVAS_WAVEVIEW (item);
if (parent_class->draw) {
(* parent_class->draw) (item, drawable, x, y, width, height);
}
fprintf (stderr, "please don't use the CanvasWaveView item in a non-aa Canvas\n");
abort ();
}
static void
gnome_canvas_waveview_bounds (GnomeCanvasItem *item, double *x1, double *y1, double *x2, double *y2)
{
GnomeCanvasWaveView *waveview = GNOME_CANVAS_WAVEVIEW (item);
*x1 = waveview->x;
*y1 = waveview->y;
*x2 = ceil (*x1 + (waveview->length_function (waveview->data_src) / waveview->samples_per_unit));
*y2 = *y1 + waveview->height;
#if 0
x = 0; y = 0;
gnome_canvas_item_i2w (item, &x, &y);
gnome_canvas_w2c_d (GNOME_CANVAS(item->canvas), x, y, &a, &b);
x = *x2;
y = *y2;
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
}
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
GnomeCanvasWaveView *waveview;
double x1, y1, x2, y2;
double dx, dy;
*/
return DBL_MAX;
#if 0
waveview = GNOME_CANVAS_WAVEVIEW (item);
*actual_item = item;
/* Find the bounds for the rectangle plus its outline width */
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;
}
/* Point is outside rectangle */
if (x < x1)
dx = x1 - x;
else if (x > x2)
dx = x - x2;
else
dx = 0.0;
if (y < y1)
dy = y1 - y;
else if (y > y2)
dy = y - y2;
else
dy = 0.0;
return sqrt (dx * dx + dy * dy);
#endif
}
View Git Blame Copy Permalink