overhaul region/range spectrum analysis

6 files changed, 474 insertions, 448 deletions

diff --git a/gtk2_ardour/analysis_window.cc b/gtk2_ardour/analysis_window.cc
index 4ed17b441a..f3d3036c73 100644
--- a/gtk2_ardour/analysis_window.cc
+++ b/gtk2_ardour/analysis_window.cc
@@ -41,20 +41,14 @@
 using namespace ARDOUR;
 using namespace PBD;
 
-AnalysisWindow::AnalysisWindow() :
-
-	  source_selection_label       (_("Signal source")),
-	  source_selection_ranges_rb   (_("Selected ranges")),
-	  source_selection_regions_rb  (_("Selected regions")),
-
-	  display_model_label                   (_("Display model")),
-	  display_model_composite_separate_rb   (_("Composite graphs for each track")),
-	  display_model_composite_all_tracks_rb (_("Composite graph of all tracks")),
-
-	  show_minmax_button	 (_("Show frequency power range")),
-	  show_normalized_button (_("Normalize values")),
-
-	  fft_graph (16384)
+AnalysisWindow::AnalysisWindow()
+	: source_selection_label       (_("Signal source"))
+	, source_selection_ranges_rb   (_("Selected ranges"))
+	, source_selection_regions_rb  (_("Selected regions"))
+	, show_minmax_button	 (_("Show frequency power range"))
+	, show_normalized_button (_("Fit dB range"))
+	, show_proportional_button (_("Proportional Spectum, -18dB"))
+	, fft_graph (16384)
 {
 	set_name(_("FFT analysis window"));
 	set_title (_("Spectral Analysis"));
@@ -107,49 +101,31 @@ AnalysisWindow::AnalysisWindow() :
 				sigc::bind ( sigc::mem_fun(*this, &AnalysisWindow::source_selection_changed), &source_selection_regions_rb));
 	}
 
-	vbox.pack_start(hseparator1, false, false);
-
-	// "Display model"
-	vbox.pack_start(display_model_label, false, false);
-	{
-		Gtk::RadioButtonGroup group = display_model_composite_separate_rb.get_group();
-		display_model_composite_all_tracks_rb.set_group (group);
-
-		display_model_composite_separate_rb.set_active();
-
-		vbox.pack_start (display_model_composite_separate_rb,   false, false);
-		vbox.pack_start (display_model_composite_all_tracks_rb, false, false);
-
-		// "Composite graphs for all tracks"
-		display_model_composite_separate_rb.signal_toggled().connect (
-				sigc::bind ( sigc::mem_fun(*this, &AnalysisWindow::display_model_changed), &display_model_composite_separate_rb));
-
-		// "Composite graph of all tracks"
-		display_model_composite_all_tracks_rb.signal_toggled().connect (
-				sigc::bind ( sigc::mem_fun(*this, &AnalysisWindow::display_model_changed), &display_model_composite_all_tracks_rb));
-	}
-
 	// Analyze button
 
 	refresh_button.set_name("EditorGTKButton");
 	refresh_button.set_label(_("Re-analyze data"));
 
+
 	refresh_button.signal_clicked().connect ( sigc::bind ( sigc::mem_fun(*this, &AnalysisWindow::analyze_data), &refresh_button));
 
 	vbox.pack_start(refresh_button, false, false, 10);
 
+	vbox.pack_start(hseparator1, false, false);
 
 	// Feature checkboxes
 
-	// minmax
-	show_minmax_button.signal_toggled().connect( sigc::mem_fun(*this, &AnalysisWindow::show_minmax_changed));
-	vbox.pack_start(show_minmax_button, false, false);
-
-	// normalize
+	// normalize, fit y-range
 	show_normalized_button.signal_toggled().connect( sigc::mem_fun(*this, &AnalysisWindow::show_normalized_changed));
 	vbox.pack_start(show_normalized_button, false, false);
 
+	// minmax
+	show_minmax_button.signal_toggled().connect( sigc::mem_fun(*this, &AnalysisWindow::show_minmax_changed));
+	vbox.pack_start(show_minmax_button, false, false);
 
+	// pink-noise / proportional spectrum
+	show_proportional_button.signal_toggled().connect( sigc::mem_fun(*this, &AnalysisWindow::show_proportional_changed));
+	vbox.pack_start(show_proportional_button, false, false);
 
 
 
@@ -186,6 +162,12 @@ AnalysisWindow::show_normalized_changed()
 }
 
 void
+AnalysisWindow::show_proportional_changed()
+{
+	fft_graph.set_show_proportioanl(show_proportional_button.get_active());
+}
+
+void
 AnalysisWindow::set_rangemode()
 {
 	source_selection_ranges_rb.set_active(true);
diff --git a/gtk2_ardour/analysis_window.h b/gtk2_ardour/analysis_window.h
index af540b9173..cee37b308f 100644
--- a/gtk2_ardour/analysis_window.h
+++ b/gtk2_ardour/analysis_window.h
@@ -46,7 +46,6 @@ namespace ARDOUR {
 	class Session;
 }
 
-
 class AnalysisWindow : public Gtk::Window, public ARDOUR::SessionHandlePtr
 {
 public:
@@ -65,10 +64,12 @@ private:
 
 	void source_selection_changed (Gtk::RadioButton *);
 	void display_model_changed    (Gtk::RadioButton *);
-	void show_minmax_changed	();
-	void show_normalized_changed	();
 
-	void analyze_data				(Gtk::Button *);
+	void show_minmax_changed ();
+	void show_normalized_changed ();
+	void show_proportional_changed ();
+
+	void analyze_data (Gtk::Button *);
 
 	struct TrackListColumns : public Gtk::TreeModel::ColumnRecord {
 		public:
@@ -95,22 +96,16 @@ private:
 
 	Gtk::Label source_selection_label;
 
-
 	Gtk::RadioButton source_selection_ranges_rb;
 	Gtk::RadioButton source_selection_regions_rb;
 
 	Gtk::HSeparator hseparator1;
 
-	Gtk::Label display_model_label;
-	Gtk::RadioButton display_model_composite_separate_rb;
-	Gtk::RadioButton display_model_composite_all_tracks_rb;
-
 	Gtk::Button refresh_button;
 
-
 	Gtk::CheckButton show_minmax_button;
 	Gtk::CheckButton show_normalized_button;
-
+	Gtk::CheckButton show_proportional_button;
 
 	// The graph
 	FFTGraph fft_graph;
diff --git a/gtk2_ardour/fft_graph.cc b/gtk2_ardour/fft_graph.cc
index 1edd483dab..d9c8c10b15 100644
--- a/gtk2_ardour/fft_graph.cc
+++ b/gtk2_ardour/fft_graph.cc
@@ -14,7 +14,6 @@
     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.
-
 */
 
 #ifdef COMPILER_MSVC
@@ -40,12 +39,15 @@ using std::min; using std::max;
 
 #include "fft_graph.h"
 #include "analysis_window.h"
+#include "public_editor.h"
+
+#include "i18n.h"
 
 using namespace std;
 using namespace Gtk;
 using namespace Gdk;
 
-FFTGraph::FFTGraph(int windowSize)
+FFTGraph::FFTGraph (int windowSize)
 {
 	_logScale = 0;
 
@@ -56,125 +58,127 @@ FFTGraph::FFTGraph(int windowSize)
 
 	_a_window = 0;
 
-	_show_minmax     = false;
-	_show_normalized = false;
+	_show_minmax       = false;
+	_show_normalized   = false;
+	_show_proportional = false;
 
-	setWindowSize(windowSize);
+	setWindowSize (windowSize);
 }
 
 void
-FFTGraph::setWindowSize(int windowSize)
+FFTGraph::setWindowSize (int windowSize)
 {
 	if (_a_window) {
 		Glib::Threads::Mutex::Lock lm  (_a_window->track_list_lock);
-		setWindowSize_internal(windowSize);
+		setWindowSize_internal (windowSize);
 	} else {
-		setWindowSize_internal(windowSize);
+		setWindowSize_internal (windowSize);
 	}
 }
 
 void
-FFTGraph::setWindowSize_internal(int windowSize)
+FFTGraph::setWindowSize_internal (int windowSize)
 {
 	// remove old tracklist & graphs
 	if (_a_window) {
-		_a_window->clear_tracklist();
+		_a_window->clear_tracklist ();
 	}
 
 	_windowSize = windowSize;
 	_dataSize = windowSize / 2;
 	if (_in != 0) {
-		fftwf_destroy_plan(_plan);
-		free(_in);
+		fftwf_destroy_plan (_plan);
+		free (_in);
 		_in = 0;
 	}
 
 	if (_out != 0) {
-		free(_out);
+		free (_out);
 		_out = 0;
 	}
 
 	if (_hanning != 0) {
-		free(_hanning);
+		free (_hanning);
 		_hanning = 0;
 	}
 
 	if (_logScale != 0) {
-		free(_logScale);
+		free (_logScale);
 		_logScale = 0;
 	}
 
 	// When destroying, window size is set to zero to free up memory
-	if (windowSize == 0)
+	if (windowSize == 0) {
 		return;
+	}
 
 	// FFT input & output buffers
-	_in      = (float *) fftwf_malloc(sizeof(float) * _windowSize);
-	_out     = (float *) fftwf_malloc(sizeof(float) * _windowSize);
+	_in  = (float *) fftwf_malloc (sizeof (float) * _windowSize);
+	_out = (float *) fftwf_malloc (sizeof (float) * _windowSize);
 
 	// Hanning window
-	_hanning = (float *) malloc(sizeof(float) * _windowSize);
-
+	_hanning = (float *) malloc (sizeof (float) * _windowSize);
 
 	// normalize the window
 	double sum = 0.0;
 
-	for (int i=0; i < _windowSize; i++) {
-		_hanning[i]=0.81f * ( 0.5f - (0.5f * (float) cos(2.0f * M_PI * (float)i / (float)(_windowSize))));
+	for (unsigned int i = 0; i < _windowSize; ++i) {
+		_hanning[i] = 0.5f - (0.5f * (float) cos (2.0f * M_PI * (float)i / (float)(_windowSize)));
 		sum += _hanning[i];
 	}
 
-	double isum = 1.0 / sum;
+	double isum = 2.0 / sum;
 
-	for (int i=0; i < _windowSize; i++) {
+	for (unsigned int i = 0; i < _windowSize; i++) {
 		_hanning[i] *= isum;
 	}
 
-	_logScale = (int *) malloc(sizeof(int) * _dataSize);
-	//float count = 0;
-	for (int i = 0; i < _dataSize; i++) {
+	_logScale = (int *) malloc (sizeof (int) * _dataSize);
+
+	for (unsigned int i = 0; i < _dataSize; i++) {
 		_logScale[i] = 0;
 	}
-	_plan = fftwf_plan_r2r_1d(_windowSize, _in, _out, FFTW_R2HC, FFTW_ESTIMATE);
+	_plan = fftwf_plan_r2r_1d (_windowSize, _in, _out, FFTW_R2HC, FFTW_MEASURE);
 }
 
-FFTGraph::~FFTGraph()
+FFTGraph::~FFTGraph ()
 {
 	// This will free everything
-	setWindowSize(0);
+	setWindowSize (0);
 }
 
 bool
 FFTGraph::on_expose_event (GdkEventExpose* /*event*/)
 {
-	redraw();
+	redraw ();
 	return true;
 }
 
 FFTResult *
-FFTGraph::prepareResult(Gdk::Color color, string trackname)
+FFTGraph::prepareResult (Gdk::Color color, string trackname)
 {
-	FFTResult *res = new FFTResult(this, color, trackname);
+	FFTResult *res = new FFTResult (this, color, trackname);
 
 	return res;
 }
 
 
 void
-FFTGraph::set_analysis_window(AnalysisWindow *a_window)
+FFTGraph::set_analysis_window (AnalysisWindow *a_window)
 {
 	_a_window = a_window;
 }
 
-void
-FFTGraph::draw_scales(Glib::RefPtr<Gdk::Window> window)
+int
+FFTGraph::draw_scales (Glib::RefPtr<Gdk::Window> window)
 {
+	int label_height = v_margin;
 
-	Glib::RefPtr<Gtk::Style> style = get_style();
-	Glib::RefPtr<Gdk::GC> black = style->get_black_gc();
-	Glib::RefPtr<Gdk::GC> white = style->get_white_gc();
+	Glib::RefPtr<Gtk::Style> style = get_style ();
+	Glib::RefPtr<Gdk::GC> black = style->get_black_gc ();
+	Glib::RefPtr<Gdk::GC> white = style->get_white_gc ();
 
-	window->draw_rectangle(black, true, 0, 0, width, height);
+	window->draw_rectangle (black, true, 0, 0, width, height);
 
 	/**
 	 *  4          5
@@ -186,97 +190,121 @@ FFTGraph::draw_scales(Glib::RefPtr<Gdk::Window> window)
 	 **/
 
 	// Line 1
-	window->draw_line(white, h_margin, v_margin, h_margin, height - v_margin );
+	window->draw_line (white, hl_margin, v_margin, hl_margin, height - v_margin);
 
 	// Line 2
-	window->draw_line(white, width - h_margin + 1, v_margin, width - h_margin + 1, height - v_margin );
+	window->draw_line (white, width - hr_margin + 1, v_margin, width - hr_margin + 1, height - v_margin);
 
 	// Line 3
-	window->draw_line(white, h_margin, height - v_margin, width - h_margin, height - v_margin );
+	window->draw_line (white, hl_margin, height - v_margin, width - hr_margin, height - v_margin);
 
-#define DB_METRIC_LENGTH 8
 	// Line 4
-	window->draw_line(white, h_margin - DB_METRIC_LENGTH, v_margin, h_margin, v_margin );
+	window->draw_line (white, 3, v_margin, hl_margin, v_margin);
 
 	// Line 5
-	window->draw_line(white, width - h_margin + 1, v_margin, width - h_margin + DB_METRIC_LENGTH, v_margin );
-
+	window->draw_line (white, width - hr_margin + 1, v_margin, width - 3, v_margin);
 
 
 	if (graph_gc == 0) {
-		graph_gc = GC::create( get_window() );
+		graph_gc = GC::create (get_window ());
 	}
 
 	Color grey;
-
-	grey.set_rgb_p(0.2, 0.2, 0.2);
-
-	graph_gc->set_rgb_fg_color( grey );
+	grey.set_rgb_p (0.2, 0.2, 0.2);
+	graph_gc->set_rgb_fg_color (grey);
 
 	if (layout == 0) {
 		layout = create_pango_layout ("");
-		layout->set_font_description (get_style()->get_font());
+		layout->set_font_description (get_style ()->get_font ());
 	}
 
-	// Draw logscale
-	int logscale_pos = 0;
-	int position_on_scale;
-
+	// Draw x-axis scale 1/3 octaves centered around 1K
+	int overlap = 0;
 
-/* TODO, write better scales and change the log function so that octaves are of equal pixel length
-	float scale_points[10] = { 55.0, 110.0, 220.0, 440.0, 880.0, 1760.0, 3520.0, 7040.0, 14080.0, 28160.0 };
+	// make sure 1K (x=0) is visible
+	for (int x = 0; x < 27; ++x) {
+		float freq = powf (2.f, x / 3.0) * 1000.f;
+		if (freq <= _fft_start) { continue; }
+		if (freq >= _fft_end) { break; }
 
-	for (int x = 0; x < 10; x++) {
-
-		// i = 0.. _dataSize-1
-		float freq_at_bin = (SR/2.0) * ((double)i / (double)_dataSize);
+		const float pos = currentScaleWidth * logf (freq / _fft_start) / _fft_log_base;
+		const int coord = floor (hl_margin + pos);
 
+		if (coord < overlap) {
+			continue;
+		}
 
+		std::stringstream ss;
+		if (freq >= 10000) {
+			ss <<  std::setprecision (1) << std::fixed << freq / 1000 << "K";
+		} else if (freq >= 1000) {
+			ss <<  std::setprecision (2) << std::fixed << freq / 1000 << "K";
+		} else {
+			ss <<  std::setprecision (0) << std::fixed << freq << "Hz";
+		}
+		layout->set_text (ss.str ());
+		int lw, lh;
+		layout->get_pixel_size (lw, lh);
+		overlap = coord + lw + 3;
 
-			freq_at_pixel = FFT_START * exp( FFT_RANGE * pixel / (double)(currentScaleWidth - 1) );
+		if (coord + lw / 2 > width - hr_margin - 2) {
+			break;
+		}
+		if (v_margin / 2 + lh > label_height) {
+			label_height = v_margin / 2 + lh;
+		}
+		window->draw_line (graph_gc, coord, v_margin, coord, height - v_margin - 1);
+		window->draw_layout (white, coord - lw / 2, v_margin / 2, layout);
 	}
-	*/
-
-	for (int x = 1; x < 8; x++) {
-		position_on_scale = (int)floor( (double)currentScaleWidth*(double)x/8.0);
-
-		while (_logScale[logscale_pos] < position_on_scale)
-			logscale_pos++;
-
-		int coord = (int)(v_margin + 1.0 + position_on_scale);
 
-		int SR = 44100;
+	// now from 1K down to 4Hz
+	for (int x = 0; x > -24; --x) {
+		float freq = powf (2.f, x / 3.0) * 1000.f;
+		if (freq >= _fft_end) { continue; }
+		if (freq <= _fft_start) { break; }
 
-		int rate_at_pos = (int)((double)(SR/2) * (double)logscale_pos / (double)_dataSize);
+		const float pos = currentScaleWidth * logf (freq / _fft_start) / _fft_log_base;
+		const int coord = floor (hl_margin + pos);
 
-		char buf[32];
-		if (rate_at_pos < 1000)
-			snprintf(buf,32,"%dHz",rate_at_pos);
-		else
-			snprintf(buf,32,"%dk",(int)floor( (float)rate_at_pos/(float)1000) );
-
-		std::string label = buf;
-
-		layout->set_text(label);
-
-		window->draw_line(graph_gc, coord, v_margin, coord, height - v_margin - 1);
-
-		int width, height;
-		layout->get_pixel_size (width, height);
+		if (x != 0 && coord > overlap) {
+			continue;
+		}
 
-		window->draw_layout(white, coord - width / 2, v_margin / 2, layout);
+		std::stringstream ss;
+		if (freq >= 10000) {
+			ss <<  std::setprecision (1) << std::fixed << freq / 1000 << "K";
+		} else if (freq >= 1000) {
+			ss <<  std::setprecision (2) << std::fixed << freq / 1000 << "K";
+		} else {
+			ss <<  std::setprecision (0) << std::fixed << freq << "Hz";
+		}
+		layout->set_text (ss.str ());
+		int lw, lh;
+		layout->get_pixel_size (lw, lh);
+		overlap = coord - lw - 3;
 
+		if (coord - lw / 2 < hl_margin + 2) {
+			break;
+		}
+		if (x == 0) {
+			// just get overlap position
+			continue;
+		}
+		if (v_margin / 2 + lh > label_height) {
+			label_height = v_margin / 2 + lh;
+		}
+		window->draw_line (graph_gc, coord, v_margin, coord, height - v_margin - 1);
+		window->draw_layout (white, coord - lw / 2, v_margin / 2, layout);
 	}
-
+	return label_height;
 }
 
 void
-FFTGraph::redraw()
+FFTGraph::redraw ()
 {
 	Glib::Threads::Mutex::Lock lm  (_a_window->track_list_lock);
 
-	draw_scales(get_window());
-
+	int yoff = draw_scales (get_window ());
 
 	if (_a_window == 0)
 		return;
@@ -284,57 +312,105 @@ FFTGraph::redraw()
 	if (!_a_window->track_list_ready)
 		return;
 
-	cairo_t *cr;
-	cr = gdk_cairo_create(GDK_DRAWABLE(get_window()->gobj()));
-	cairo_set_line_width(cr, 1.5);
-	cairo_translate(cr, (float)v_margin + 1.0, (float)h_margin);
-
+	float minf;
+	float maxf;
 
+	TreeNodeChildren track_rows = _a_window->track_list.get_model ()->children ();
 
-	// Find "session wide" min & max
-	float minf =  1000000000000.0;
-	float maxf = -1000000000000.0;
-
-	TreeNodeChildren track_rows = _a_window->track_list.get_model()->children();
-
-	for (TreeIter i = track_rows.begin(); i != track_rows.end(); i++) {
-
-		TreeModel::Row row = *i;
-		FFTResult *res = row[_a_window->tlcols.graph];
+	if (!_show_normalized) {
+		maxf =    0.0f;
+		minf = -108.0f;
+	} else  {
+		minf =  999.0f;
+		maxf = -999.0f;
+		for (TreeIter i = track_rows.begin (); i != track_rows.end (); i++) {
+			TreeModel::Row row = *i;
+			FFTResult *res = row[_a_window->tlcols.graph];
+
+			// disregard fft analysis from empty signals
+			if (res->minimum (_show_proportional) == res->maximum (_show_proportional)) {
+				continue;
+			}
+			// don't include invisible graphs
+			if (!row[_a_window->tlcols.visible]) {
+				continue;
+			}
 
-		// disregard fft analysis from empty signals
-		if (res->minimum() == res->maximum()) {
-			continue;
+			minf = std::min (minf, res->minimum (_show_proportional));
+			maxf = std::max (maxf, res->maximum (_show_proportional));
 		}
+	}
 
-		if ( res->minimum() < minf) {
-			minf = res->minimum();
-		}
+	// clamp range, > -200dBFS, at least 24dB (two y-axis labels) range
+	minf = std::max (-200.f, minf);
+	if (maxf <= minf) {
+		return;
+	}
 
-		if ( res->maximum() > maxf) {
-			maxf = res->maximum();
-		}
+	if (maxf - minf < 24) {
+		maxf += 6.f;
+		minf = maxf - 24.f;
 	}
 
-	if (!_show_normalized) {
-		minf = -150.0f;
-		maxf = 0.0f;
+	cairo_t *cr;
+	cr = gdk_cairo_create (GDK_DRAWABLE (get_window ()->gobj ()));
+	cairo_set_line_width (cr, 1.5);
+	cairo_translate (cr, hl_margin + 1, yoff);
+
+	float fft_pane_size_w = width  - hl_margin - hr_margin;
+	float fft_pane_size_h = height - v_margin - 1 - yoff;
+	double pixels_per_db = (double)fft_pane_size_h / (double)(maxf - minf);
+
+	// draw y-axis dB
+	cairo_set_source_rgba (cr, .8, .8, .8, 1.0);
+
+	int btm_lbl = fft_pane_size_h;
+	{
+		// y-axis legend
+		layout->set_text (_("dBFS"));
+		int lw, lh;
+		layout->get_pixel_size (lw, lh);
+		cairo_move_to (cr, -2 - lw, fft_pane_size_h - lh / 2);
+		pango_cairo_update_layout (cr, layout->gobj ());
+		pango_cairo_show_layout (cr, layout->gobj ());
+		btm_lbl = fft_pane_size_h - lh;
 	}
 
-	//int graph_height = height - 2 * h_margin;
+	for (int x = -6; x >= -200; x -= 12) {
+		float yp = 1.5 + fft_pane_size_h - rint ((x - minf) * pixels_per_db);
 
+		assert (layout);
+		std::stringstream ss;
+		ss << x;
+		layout->set_text (ss.str ());
+		int lw, lh;
+		layout->get_pixel_size (lw, lh);
 
+		if (yp + 2 + lh / 2 > btm_lbl) {
+			continue;
+		}
+		if (yp < 2 + lh / 2) {
+			continue;
+		}
 
-	float fft_pane_size_w = (float)(width  - 2*v_margin) - 1.0;
-	float fft_pane_size_h = (float)(height - 2*h_margin);
+		cairo_set_source_rgba (cr, .8, .8, .8, 1.0);
+		cairo_move_to (cr, -2 - lw, yp - lh / 2);
+		pango_cairo_update_layout (cr, layout->gobj ());
+		pango_cairo_show_layout (cr, layout->gobj ());
 
-	double pixels_per_db = (double)fft_pane_size_h / (double)(maxf - minf);
+		cairo_set_source_rgba (cr, .2, .2, .2, 1.0);
+		cairo_move_to (cr, 0, yp);
+		cairo_line_to (cr, fft_pane_size_w, yp);
+		cairo_stroke (cr);
+	}
 
-	cairo_rectangle(cr, 0.0, 0.0, fft_pane_size_w, fft_pane_size_h);
-	cairo_clip(cr);
+	cairo_rectangle (cr, 1, 1, fft_pane_size_w, fft_pane_size_h);
+	cairo_clip (cr);
 
-	for (TreeIter i = track_rows.begin(); i != track_rows.end(); i++) {
+	cairo_set_line_cap (cr, CAIRO_LINE_CAP_BUTT);
+	cairo_set_line_join (cr, CAIRO_LINE_JOIN_ROUND);
 
+	for (TreeIter i = track_rows.begin (); i != track_rows.end (); i++) {
 		TreeModel::Row row = *i;
 
 		// don't show graphs for tracks which are deselected
@@ -345,144 +421,117 @@ FFTGraph::redraw()
 		FFTResult *res = row[_a_window->tlcols.graph];
 
 		// don't show graphs for empty signals
-		if (res->minimum() == res->maximum()) {
+		if (res->minimum (_show_proportional) == res->maximum (_show_proportional)) {
 			continue;
 		}
 
 		float mpp;
+		float X,Y;
 
 		if (_show_minmax) {
-			mpp = -1000000.0;
 
-			cairo_set_source_rgba(cr, res->get_color().get_red_p(), res->get_color().get_green_p(), res->get_color().get_blue_p(), 0.30);
-			cairo_move_to(cr, 0.5f + (float)_logScale[0], 0.5f + (float)( fft_pane_size_h - (int)floor( (res->maxAt(0) - minf) * pixels_per_db) ));
+			X = 0.5f + _logScale[0];
+			Y = 1.5f + fft_pane_size_h - pixels_per_db * (res->maxAt (0, _show_proportional) - minf);
+			cairo_move_to (cr, X, Y);
 
 			// Draw the line of maximum values
-			for (int x = 1; x < res->length(); x++) {
-				if (res->maxAt(x) > mpp)
-					mpp = res->maxAt(x);
-				mpp = fmax(mpp, minf);
-				mpp = fmin(mpp, maxf);
-
-				// If the next point on the log scale is at the same location,
-				// don't draw yet
-				if (x + 1 < res->length() && _logScale[x] == _logScale[x + 1]) {
+			mpp = minf;
+			for (unsigned int x = 1; x < res->length () - 1; ++x) {
+				mpp = std::max (mpp, res->maxAt (x, _show_proportional));
+
+				if (_logScale[x] == _logScale[x + 1]) {
 					continue;
 				}
 
-				float X = 0.5f + (float)_logScale[x];
-				float Y = 0.5f + (float)( fft_pane_size_h - (int)floor( (mpp - minf) * pixels_per_db) );
-
-				cairo_line_to(cr, X, Y);
-
-				mpp = -1000000.0;
+				mpp = fmin (mpp, maxf);
+				X = 0.5f + _logScale[x];
+				Y = 1.5f + fft_pane_size_h - pixels_per_db * (mpp - minf);
+				cairo_line_to (cr, X, Y);
+				mpp = minf;
 			}
 
-			mpp = +10000000.0;
+			mpp = maxf;
 			// Draw back to the start using the minimum value
-			for (int x = res->length()-1; x >= 0; x--) {
-				if (res->minAt(x) < mpp)
-					mpp = res->minAt(x);
-				mpp = fmax(mpp, minf);
-				mpp = fmin(mpp, maxf);
-
-				// If the next point on the log scale is at the same location,
-				// don't draw yet
-				if (x - 1 > 0 && _logScale[x] == _logScale[x - 1]) {
+			for (int x = res->length () - 1; x >= 0; --x) {
+				mpp = std::min (mpp, res->minAt (x, _show_proportional));
+
+				if (_logScale[x] == _logScale[x + 1]) {
 					continue;
 				}
 
-				float X = 0.5f + (float)_logScale[x];
-				float Y = 0.5f + (float)( fft_pane_size_h - (int)floor( (mpp - minf) * pixels_per_db) );
-
-				cairo_line_to(cr, X, Y );
-
-				mpp = +10000000.0;
+				mpp = fmax (mpp, minf);
+				X = 0.5f + _logScale[x];
+				Y = 1.5f + fft_pane_size_h - pixels_per_db * (mpp - minf);
+				cairo_line_to (cr, X, Y);
+				mpp = maxf;
 			}
 
-			cairo_close_path(cr);
-
-			cairo_fill(cr);
+			cairo_set_source_rgba (cr, res->get_color ().get_red_p (), res->get_color ().get_green_p (), res->get_color ().get_blue_p (), 0.30);
+			cairo_close_path (cr);
+			cairo_fill (cr);
 		}
 
+		// draw max of averages
+		X = 0.5f + _logScale[0];
+		Y = 1.5f + fft_pane_size_h - pixels_per_db * (res->avgAt (0, _show_proportional) - minf);
+		cairo_move_to (cr, X, Y);
 
+		mpp = minf;
+		for (unsigned int x = 0; x < res->length () - 1; x++) {
+			mpp = std::max (mpp, res->avgAt (x, _show_proportional));
 
-		// Set color from track
-		cairo_set_source_rgb(cr, res->get_color().get_red_p(), res->get_color().get_green_p(), res->get_color().get_blue_p());
-
-		mpp = -1000000.0;
-
-		cairo_move_to(cr, 0.5, fft_pane_size_h-0.5);
-
-		for (int x = 0; x < res->length(); x++) {
-
-
-			if (res->avgAt(x) > mpp)
-				mpp = res->avgAt(x);
-			mpp = fmax(mpp, minf);
-			mpp = fmin(mpp, maxf);
-
-			// If the next point on the log scale is at the same location,
-			// don't draw yet
-			if (x + 1 < res->length() && _logScale[x] == _logScale[x + 1]) {
+			if (_logScale[x] == _logScale[x + 1]) {
 				continue;
 			}
 
-			cairo_line_to(cr, 0.5f + (float)_logScale[x], 0.5f + (float)( fft_pane_size_h - (int)floor( (mpp - minf) * pixels_per_db) ));
+			mpp = fmax (mpp, minf);
+			mpp = fmin (mpp, maxf);
 
-			mpp = -1000000.0;
+			X = 0.5f + _logScale[x];
+			Y = 1.5f + fft_pane_size_h - pixels_per_db * (mpp - minf);
+			cairo_line_to (cr, X, Y);
+			mpp = minf;
 		}
 
-		cairo_stroke(cr);
+		cairo_set_source_rgb (cr, res->get_color ().get_red_p (), res->get_color ().get_green_p (), res->get_color ().get_blue_p ());
+		cairo_stroke (cr);
 	}
-
-	cairo_destroy(cr);
+	cairo_destroy (cr);
 }
 
 void
-FFTGraph::on_size_request(Gtk::Requisition* requisition)
+FFTGraph::on_size_request (Gtk::Requisition* requisition)
 {
-	width  = max(requisition->width,  minScaleWidth  + h_margin * 2);
-	height = max(requisition->height, minScaleHeight + 2 + v_margin * 2);
+	width  = max (requisition->width,  minScaleWidth  + hl_margin + hr_margin);
+	height = max (requisition->height, minScaleHeight + 2 + v_margin * 2);
 
-	update_size();
+	update_size ();
 
 	requisition->width  = width;;
 	requisition->height = height;
 }
 
 void
-FFTGraph::on_size_allocate(Gtk::Allocation & alloc)
+FFTGraph::on_size_allocate (Gtk::Allocation & alloc)
 {
-	width = alloc.get_width();
-	height = alloc.get_height();
+	width = alloc.get_width ();
+	height = alloc.get_height ();
 
-	update_size();
+	update_size ();
 
 	DrawingArea::on_size_allocate (alloc);
 }
 
 void
-FFTGraph::update_size()
+FFTGraph::update_size ()
 {
-	currentScaleWidth  = width - h_margin*2;
-	currentScaleHeight = height - 2 - v_margin*2;
-
-	float SR = 44100;
-	float FFT_START = SR/(double)_dataSize;
-	float FFT_END = SR/2.0;
-	float FFT_RANGE = log( FFT_END / FFT_START);
-	float pixel = 0;
-	for (int i = 0; i < _dataSize; i++) {
-		float freq_at_bin = (SR/2.0) * ((double)i / (double)_dataSize);
-		float freq_at_pixel;
-		pixel--;
-		do {
-			pixel++;
-			freq_at_pixel = FFT_START * exp( FFT_RANGE * pixel / (double)(currentScaleWidth - 1) );
-		} while (freq_at_bin > freq_at_pixel);
-
-		_logScale[i] = (int)floor(pixel);
+	framecnt_t SR = PublicEditor::instance ().session ()->nominal_frame_rate ();
+	_fft_start = SR / (double)_dataSize;
+	_fft_end = .5 * SR;
+	_fft_log_base = logf (.5 * _dataSize);
+	currentScaleWidth  = width - hl_margin - hr_margin;
+	_logScale[0] = 0;
+	for (unsigned int i = 1; i < _dataSize; ++i) {
+		_logScale[i] = floor (currentScaleWidth * logf (.5 * i) / _fft_log_base);
 	}
 }
-
diff --git a/gtk2_ardour/fft_graph.h b/gtk2_ardour/fft_graph.h
index ab05da348b..75cda4d457 100644
--- a/gtk2_ardour/fft_graph.h
+++ b/gtk2_ardour/fft_graph.h
@@ -38,62 +38,68 @@ class AnalysisWindow;
 
 class FFTGraph : public Gtk::DrawingArea
 {
-	public:
+public:
 
-		FFTGraph(int windowSize);
-		~FFTGraph();
+	FFTGraph (int windowSize);
+	~FFTGraph ();
 
-		void set_analysis_window(AnalysisWindow *a_window);
+	void set_analysis_window (AnalysisWindow *a_window);
 
-		int windowSize() const { return _windowSize; }
-		void setWindowSize(int windowSize);
+	int windowSize () const { return _windowSize; }
+	void setWindowSize (int windowSize);
 
-		void redraw();
-		bool on_expose_event (GdkEventExpose* event);
+	void redraw ();
+	bool on_expose_event (GdkEventExpose* event);
 
-		void on_size_request(Gtk::Requisition* requisition);
-		void on_size_allocate(Gtk::Allocation & alloc);
-		FFTResult *prepareResult(Gdk::Color color, std::string trackname);
+	void on_size_request (Gtk::Requisition* requisition);
+	void on_size_allocate (Gtk::Allocation & alloc);
+	FFTResult *prepareResult (Gdk::Color color, std::string trackname);
 
-		void set_show_minmax     (bool v) { _show_minmax     = v; redraw(); }
-		void set_show_normalized (bool v) { _show_normalized = v; redraw(); }
+	void set_show_minmax      (bool v) { _show_minmax       = v; redraw (); }
+	void set_show_normalized  (bool v) { _show_normalized   = v; redraw (); }
+	void set_show_proportioanl(bool v) { _show_proportional = v; redraw (); }
 
-	private:
+private:
 
-		void update_size();
+	void update_size ();
 
-		void setWindowSize_internal(int windowSize);
+	void setWindowSize_internal (int windowSize);
 
-		void draw_scales(Glib::RefPtr<Gdk::Window> window);
+	int draw_scales (Glib::RefPtr<Gdk::Window> window);
 
-		static const int minScaleWidth = 512;
-		static const int minScaleHeight = 420;
+	static const int minScaleWidth = 512;
+	static const int minScaleHeight = 420;
 
-		int currentScaleWidth;
-		int currentScaleHeight;
+	static const int hl_margin = 40; // this should scale with font (dBFS labels)
+	static const int hr_margin = 12;
+	static const int v_margin  = 12;
 
-		static const int h_margin = 20;
-		static const int v_margin = 20;
-		Glib::RefPtr<Gdk::GC> graph_gc;
+	int currentScaleWidth;
+	Glib::RefPtr<Gdk::GC> graph_gc;
 
-		int width;
-		int height;
+	int width;
+	int height;
 
-		int _windowSize;
-		int _dataSize;
+	unsigned int _windowSize;
+	unsigned int _dataSize;
 
-		Glib::RefPtr<Pango::Layout> layout;
-		AnalysisWindow *_a_window;
+	Glib::RefPtr<Pango::Layout> layout;
+	AnalysisWindow *_a_window;
 
-		fftwf_plan _plan;
+	fftwf_plan _plan;
 
-		float *_out;
-		float *_in;
-		float *_hanning;
-		int *_logScale;
+	float* _out;
+	float* _in;
+	float* _hanning;
+	int*   _logScale;
 
-		bool _show_minmax;
-		bool _show_normalized;
+	bool _show_minmax;
+	bool _show_normalized;
+	bool _show_proportional;
+
+	float _fft_start;
+	float _fft_end;
+	float _fft_log_base;
 
 	friend class FFTResult;
 };
diff --git a/gtk2_ardour/fft_result.cc b/gtk2_ardour/fft_result.cc
index a83b65e854..b4a82c2586 100644
--- a/gtk2_ardour/fft_result.cc
+++ b/gtk2_ardour/fft_result.cc
@@ -1,22 +1,21 @@
 /*
-    Copyright (C) 2006 Paul Davis
-	Written by Sampo Savolainen
-
-    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.
-
-*/
+ * Copyright (C) 2006, 2016 Paul Davis
+ * Written by Sampo Savolainen & Robin Gareus
+ *
+ * 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
 
 #include "fft_result.h"
 #include "fft_graph.h"
@@ -24,8 +23,7 @@
 #include <cstring>
 #include <string>
 #include <cmath>
-
-#include <iostream>
+#include <algorithm>
 
 using namespace std;
 
@@ -35,18 +33,24 @@ FFTResult::FFTResult(FFTGraph *graph, Gdk::Color color, string trackname)
 
 	_windowSize = _graph->windowSize();
 	_dataSize   = _windowSize / 2;
-
 	_averages = 0;
-
-	_data_avg = (float *) malloc(sizeof(float) * _dataSize);
-	memset(_data_avg,0,sizeof(float) * _dataSize);
-
-	_data_min = (float *) malloc(sizeof(float) * _dataSize);
-	_data_max = (float *) malloc(sizeof(float) * _dataSize);
-
-	for (int i = 0; i < _dataSize; i++) {
-		_data_min[i] = FLT_MAX;
-		_data_max[i] = FLT_MIN;
+	_min_flat = _max_flat = 0.0;
+	_min_prop = _max_prop = 0.0;
+
+	_data_flat_avg = (float *) malloc (sizeof(float) * _dataSize);
+	_data_flat_min = (float *) malloc (sizeof(float) * _dataSize);
+	_data_flat_max = (float *) malloc (sizeof(float) * _dataSize);
+	_data_prop_avg = (float *) malloc (sizeof(float) * _dataSize);
+	_data_prop_min = (float *) malloc (sizeof(float) * _dataSize);
+	_data_prop_max = (float *) malloc (sizeof(float) * _dataSize);
+
+	for (unsigned int i = 0; i < _dataSize; i++) {
+		_data_flat_min[i] = FLT_MAX;
+		_data_flat_max[i] = FLT_MIN;
+		_data_flat_avg[i] = 0;
+		_data_prop_min[i] = FLT_MAX;
+		_data_prop_max[i] = FLT_MIN;
+		_data_prop_avg[i] = 0;
 	}
 
 	_color     = color;
@@ -56,34 +60,31 @@ FFTResult::FFTResult(FFTGraph *graph, Gdk::Color color, string trackname)
 void
 FFTResult::analyzeWindow(float *window)
 {
-	float *_hanning = _graph->_hanning;
+	float const * const _hanning = _graph->_hanning;
 	float *_in = _graph->_in;
 	float *_out = _graph->_out;
 
-	int i;
 	// Copy the data and apply the hanning window
-	for (i = 0; i < _windowSize; i++) {
-		_in[i] = window[ i ] * _hanning[ i ];
+	for (unsigned int i = 0; i < _windowSize; ++i) {
+		_in[i] = window[i] * _hanning[i];
 	}
 
 	fftwf_execute(_graph->_plan);
 
+	// calculate signal power per bin
 	float b = _out[0] * _out[0];
 
-	_data_avg[0] += b;
-	if (b < _data_min[0]) _data_min[0] = b;
-	if (b > _data_max[0]) _data_max[0] = b;
-
-	for (i=1; i < _dataSize - 1; i++) { // TODO: check with Jesse whether this is really correct
-		b = (_out[i] * _out[i]);
-
-		_data_avg[i] += b;  // + (_out[_windowSize-i] * _out[_windowSize-i]);, TODO: thanks to Stefan Kost
+	_data_flat_avg[0] += b;
+	if (b < _data_flat_min[0]) _data_flat_min[0] = b;
+	if (b > _data_flat_max[0]) _data_flat_max[0] = b;
 
-		if (_data_min[i] > b)  _data_min[i] = b;
-		if (_data_max[i] < b ) _data_max[i] = b;
+	for (unsigned int i = 1; i < _dataSize - 1; ++i) {
+		b = (_out[i] * _out[i]) + (_out[_windowSize - i] * _out[_windowSize - i]);
+		_data_flat_avg[i] += b;
+		if (_data_flat_min[i] > b)  _data_flat_min[i] = b;
+		if (_data_flat_max[i] < b ) _data_flat_max[i] = b;
 	}
 
-
 	_averages++;
 }
 
@@ -91,32 +92,43 @@ void
 FFTResult::finalize()
 {
 	if (_averages == 0) {
-		_minimum = 0.0;
-		_maximum = 0.0;
+		_min_flat = _max_flat = 0.0;
+		_min_prop = _max_prop = 0.0;
 		return;
 	}
 
 	// Average & scale
-	for (int i = 0; i < _dataSize; i++) {
-		_data_avg[i] /= _averages;
-		_data_avg[i]  = 10.0f * log10f(_data_avg[i]);
-
-		_data_min[i]  = 10.0f * log10f(_data_min[i]);
-		if (_data_min[i] < -10000.0f) {
-			_data_min[i] = -10000.0f;
-		}
-		_data_max[i]  = 10.0f * log10f(_data_max[i]);
+	for (unsigned int i = 0; i < _dataSize - 1; ++i) {
+		_data_flat_avg[i] /= _averages;
+		// proportional, pink spectrum @ -18dB
+		_data_prop_avg[i] = _data_flat_avg [i] * i / 63.096f;
+		_data_prop_min[i] = _data_flat_min [i] * i / 63.096f;
+		_data_prop_max[i] = _data_flat_max [i] * i / 63.096f;
+	}
+
+	_data_prop_avg[0] = _data_flat_avg [0] / 63.096f;
+	_data_prop_min[0] = _data_flat_min [0] / 63.096f;
+	_data_prop_max[0] = _data_flat_max [0] / 63.096f;
+
+	// calculate power
+	for (unsigned int i = 0; i < _dataSize - 1; ++i) {
+		_data_flat_min[i] = power_to_db (_data_flat_min[i]);
+		_data_flat_max[i] = power_to_db (_data_flat_max[i]);
+		_data_flat_avg[i] = power_to_db (_data_flat_avg[i]);
+		_data_prop_min[i] = power_to_db (_data_prop_min[i]);
+		_data_prop_max[i] = power_to_db (_data_prop_max[i]);
+		_data_prop_avg[i] = power_to_db (_data_prop_avg[i]);
 	}
 
 	// find min & max
-	_minimum = _maximum = _data_avg[0];
-
-	for (int i = 1; i < _dataSize; i++) {
-		if (_data_avg[i] < _minimum        && !isinf(_data_avg[i])) {
-			_minimum = _data_avg[i];
-		} else if (_data_avg[i] > _maximum && !isinf(_data_avg[i])) {
-			_maximum = _data_avg[i];
-		}
+	_min_flat = _max_flat = _data_flat_avg[0];
+	_min_prop = _max_prop = _data_prop_avg[0];
+
+	for (unsigned int i = 1; i < _dataSize - 1; ++i) {
+		_min_flat = std::min (_min_flat, _data_flat_avg[i]);
+		_max_flat = std::max (_max_flat, _data_flat_avg[i]);
+		_min_prop = std::min (_min_prop, _data_prop_avg[i]);
+		_max_prop = std::max (_max_prop, _data_prop_avg[i]);
 	}
 
 	_averages = 0;
@@ -124,36 +136,10 @@ FFTResult::finalize()
 
 FFTResult::~FFTResult()
 {
-	free(_data_avg);
-	free(_data_min);
-	free(_data_max);
+	free(_data_flat_avg);
+	free(_data_flat_min);
+	free(_data_flat_max);
+	free(_data_prop_avg);
+	free(_data_prop_min);
+	free(_data_prop_max);
 }
-
-
-float
-FFTResult::avgAt(int x)
-{
-	if (x < 0 || x>= _dataSize)
-		return 0.0f;
-
-	return _data_avg[x];
-}
-
-float
-FFTResult::minAt(int x)
-{
-	if (x < 0 || x>= _dataSize)
-		return 0.0f;
-
-	return _data_min[x];
-}
-
-float
-FFTResult::maxAt(int x)
-{
-	if (x < 0 || x>= _dataSize)
-		return 0.0f;
-
-	return _data_max[x];
-}
-
diff --git a/gtk2_ardour/fft_result.h b/gtk2_ardour/fft_result.h
index ddf2bb1842..dfab35a35f 100644
--- a/gtk2_ardour/fft_result.h
+++ b/gtk2_ardour/fft_result.h
@@ -1,22 +1,21 @@
 /*
-    Copyright (C) 2006 Paul Davis
-	Written by Sampo Savolainen
-
-    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.
-
-*/
+ * Copyright (C) 2006, 2016 Paul Davis
+ * Written by Sampo Savolainen & Robin Gareus
+ *
+ * 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
 
 #ifndef __ardour_fft_result_h
 #define __ardour_fft_result_h
@@ -31,47 +30,56 @@ class FFTGraph;
 
 class FFTResult
 {
-	public:
+public:
 
-		~FFTResult();
+	~FFTResult ();
 
-		void analyzeWindow(float *window);
-		void finalize();
+	void analyzeWindow (float *window);
+	void finalize ();
 
-		int length() const { return _dataSize; }
+	unsigned int length () const { return _dataSize; }
 
-		float avgAt(int x);
-		float maxAt(int x);
-		float minAt(int x);
+	float avgAt (unsigned int x, bool p) const
+	{ return p ? _data_prop_avg[x] : _data_flat_avg[x]; }
+	float maxAt (unsigned int x, bool p) const
+	{ return p ? _data_prop_max[x] : _data_flat_max[x]; }
+	float minAt (unsigned int x, bool p) const
+	{ return p ? _data_prop_min[x] : _data_flat_min[x]; }
 
-		float minimum() const { return _minimum; }
-		float maximum() const { return _maximum; }
+	float minimum (bool p) const
+	{ return p ? _min_prop : _min_flat; }
+	float maximum (bool p) const
+	{ return p ? _max_prop : _max_flat; }
 
-		Gdk::Color get_color() const { return _color; }
+	const Gdk::Color& get_color () const { return _color; }
 
-	private:
-		FFTResult(FFTGraph *graph, Gdk::Color color, std::string trackname);
-
-		int 	_averages;
+private:
+	FFTResult (FFTGraph *graph, Gdk::Color color, std::string trackname);
+	friend class FFTGraph;
 
-		float*	_data_avg;
-		float*  _data_max;
-		float*  _data_min;
+	int _averages;
 
-		float*	_work;
+	float* _data_flat_avg;
+	float* _data_flat_max;
+	float* _data_flat_min;
+	float* _data_prop_avg;
+	float* _data_prop_max;
+	float* _data_prop_min;
 
-		int	_windowSize;
-		int 	_dataSize;
+	unsigned int _windowSize;
+	unsigned int _dataSize;
 
-		float 	_minimum;
-		float 	_maximum;
+	float _min_flat;
+	float _max_flat;
+	float _min_prop;
+	float _max_prop;
 
-		FFTGraph *_graph;
+	FFTGraph *_graph;
 
-		Gdk::Color _color;
-		std::string _trackname;
+	Gdk::Color _color;
+	std::string _trackname;
 
-	friend class FFTGraph;
+	static float power_to_db (float v) { return v > 1e-20 ? 10.0f * log10f (v) : -200.0f; }
 };
 
 #endif /* __ardour_fft_result_h */