diff options
author | Sampo Savolainen <v2@iki.fi> | 2006-03-12 21:58:52 +0000 |
---|---|---|
committer | Sampo Savolainen <v2@iki.fi> | 2006-03-12 21:58:52 +0000 |
commit | 3891c733af596666b4ed98765d36226582ad624c (patch) | |
tree | 727851e983971da1c38a601a6712eb8c7ca9254d /gtk2_ardour/fft_graph.cc | |
parent | a505e1469d362cc32acb01252d192c73729fbc43 (diff) |
First commit on FFT analysis window. Still some functionality missing,
but it's mostly done.
git-svn-id: svn://localhost/trunk/ardour2@383 d708f5d6-7413-0410-9779-e7cbd77b26cf
Diffstat (limited to 'gtk2_ardour/fft_graph.cc')
-rw-r--r-- | gtk2_ardour/fft_graph.cc | 397 |
1 files changed, 397 insertions, 0 deletions
diff --git a/gtk2_ardour/fft_graph.cc b/gtk2_ardour/fft_graph.cc new file mode 100644 index 0000000000..0989247e09 --- /dev/null +++ b/gtk2_ardour/fft_graph.cc @@ -0,0 +1,397 @@ +/* + Copyright (C) 2006 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. + +*/ + +#include <iostream> + +#include <glibmm.h> +#include <glibmm/refptr.h> + +#include <gdkmm/gc.h> + +#include <gtkmm/widget.h> +#include <gtkmm/style.h> +#include <gtkmm/treemodel.h> +#include <gtkmm/treepath.h> + +#include <pbd/stl_delete.h> + +#include <math.h> + +#include "fft_graph.h" +#include "analysis_window.h" + +using namespace std; +using namespace Gtk; +using namespace Gdk; + +FFTGraph::FFTGraph(int windowSize) +{ + _logScale = 0; + + _in = 0; + _out = 0; + _hanning = 0; + _logScale = 0; + + _a_window = 0; + + setWindowSize(windowSize); +} + +void +FFTGraph::setWindowSize(int windowSize) +{ + if (_a_window) { + LockMonitor lm (_a_window->track_list_lock, __LINE__, __FILE__); + setWindowSize_internal(windowSize); + } else { + setWindowSize_internal(windowSize); + } +} + +void +FFTGraph::setWindowSize_internal(int windowSize) +{ + // remove old tracklist & graphs + if (_a_window) { + _a_window->clear_tracklist(); + } + + _windowSize = windowSize; + _dataSize = windowSize / 2; + if (_in != 0) { + fftwf_destroy_plan(_plan); + free(_in); + _in = 0; + } + + if (_out != 0) { + free(_out); + _out = 0; + } + + if (_hanning != 0) { + free(_hanning); + _hanning = 0; + } + + if (_logScale != 0) { + free(_logScale); + _logScale = 0; + } + + // When destroying, window size is set to zero to free up memory + if (windowSize == 0) + return; + + // FFT input & output buffers + _in = (float *) fftwf_malloc(sizeof(float) * _windowSize); + _out = (float *) fftwf_malloc(sizeof(float) * _windowSize); + + // Hanning window + _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)))); + sum += _hanning[i]; + } + + double isum = 1.0 / sum; + + for (int i=0; i < _windowSize; i++) { + _hanning[i] *= isum; + } + + _logScale = (int *) malloc(sizeof(int) * _dataSize); + for (int i = 0; i < _dataSize; i++) { + _logScale[i] = (int)floor(log10( 1.0 + i * 9.0 / (double)_dataSize) * (double)scaleWidth); + } + _plan = fftwf_plan_r2r_1d(_windowSize, _in, _out, FFTW_R2HC, FFTW_ESTIMATE); +} + +FFTGraph::~FFTGraph() +{ + // This will free everything + setWindowSize(0); +} + +bool +FFTGraph::on_expose_event (GdkEventExpose* event) +{ + redraw(); + return true; +} + +FFTResult * +FFTGraph::prepareResult(Gdk::Color color, string trackname) +{ + FFTResult *res = new FFTResult(this, color, trackname); + + return res; +} + +void +FFTGraph::analyze(float *window, float *composite) +{ + int i; + // Copy the data and apply the hanning window + for (i = 0; i < _windowSize; i++) { + _in[i] = window[ i ] * _hanning[ i ]; + } + + fftwf_execute(_plan); + + composite[0] += (_out[0] * _out[0]); + + for (i=1; i < _dataSize - 1; i++) { // TODO: check with Jesse whether this is really correct + composite[i] += (_out[i] * _out[i]) + (_out[_windowSize-i] * _out[_windowSize-i]); + } +} + +void +FFTGraph::set_analysis_window(AnalysisWindow *a_window) +{ + _a_window = a_window; +} + +void +FFTGraph::draw_scales(Glib::RefPtr<Gdk::Window> window) +{ + + 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); + + /** + * 4 5 + * _ _ + * | | + * 1 | | 2 + * |________| + * 3 + **/ + + // Line 1 + window->draw_line(white, h_margin, v_margin, h_margin, height - v_margin ); + + // Line 2 + window->draw_line(white, width - h_margin, v_margin, width - h_margin, height - v_margin ); + + // Line 3 + window->draw_line(white, h_margin, height - v_margin, width - h_margin, height - v_margin ); + +#define DB_METRIC_LENGTH 8 + // Line 5 + window->draw_line(white, h_margin - DB_METRIC_LENGTH, v_margin, h_margin, v_margin ); + + // Line 6 + window->draw_line(white, width - h_margin, v_margin, width - h_margin + DB_METRIC_LENGTH, v_margin ); + + + if (graph_gc == 0) { + 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 ); + + if (layout == 0) { + layout = create_pango_layout (""); + layout->set_font_description (get_style()->get_font()); + } + + // Draw logscale + int logscale_pos = 0; + int position_on_scale; + for (int x = 1; x < 8; x++) { + position_on_scale = (int)floor( (double)scaleWidth*(double)x/8.0); + + while (_logScale[logscale_pos] < position_on_scale) + logscale_pos++; + + int coord = v_margin + 1.0 + position_on_scale; + + int SR = 44100; + + int rate_at_pos = (double)(SR/2) * (double)logscale_pos / (double)_dataSize; + + char buf[32]; + snprintf(buf,32,"%dhz",rate_at_pos); + + std::string label = buf; + + layout->set_text(label); + + window->draw_line(graph_gc, coord, v_margin, coord, height - v_margin); + + int layoutWidth; + int layoutHeight; + layout->get_pixel_size(layoutWidth,layoutHeight); + + + window->draw_layout(white, coord - layoutWidth / 2, v_margin / 2, layout); + + } + +} + +void +FFTGraph::redraw() +{ + LockMonitor lm (_a_window->track_list_lock, __LINE__, __FILE__ ); + + draw_scales(get_window()); + + if (_a_window == 0) + return; + + if (!_a_window->track_list_ready) + return; + + + // Find "session wide" min & max + float min = 1000000000000.0; + float max = -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]; + + // disregard fft analysis from empty signals + if (res->minimum() == res->maximum()) { + continue; + } + + if ( res->minimum() < min) { + min = res->minimum(); + } + + if ( res->maximum() > max) { + max = res->maximum(); + } + } + + int graph_height = height - 2 * h_margin; + + if (graph_gc == 0) { + graph_gc = GC::create( get_window() ); + } + + + double pixels_per_db = (double)graph_height / (double)(max - min); + + + for (TreeIter i = track_rows.begin(); i != track_rows.end(); i++) { + + TreeModel::Row row = *i; + + // don't show graphs for tracks which are deselected + if (!row[_a_window->tlcols.visible]) { + continue; + } + + FFTResult *res = row[_a_window->tlcols.graph]; + + // don't show graphs for empty signals + if (res->minimum() == res->maximum()) { + continue; + } + + std::string name = row[_a_window->tlcols.trackname]; + + // Set color from track + graph_gc->set_rgb_fg_color( res->get_color() ); + + float mpp = -1000000.0; + int prevx = 0; + float prevSample = min; + + for (int x = 0; x < res->length() - 1; x++) { + + if (res->sampleAt(x) > mpp) + mpp = res->sampleAt(x); + + // 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]) { + continue; + } + + get_window()->draw_line( + graph_gc, + v_margin + 1 + prevx, + graph_height - (int)floor( (prevSample - min) * pixels_per_db) + h_margin - 1, + v_margin + 1 + _logScale[x], + graph_height - (int)floor( (mpp - min) * pixels_per_db) + h_margin - 1); + + prevx = _logScale[x]; + prevSample = mpp; + + + mpp = -1000000.0; + + } + } + +} + +void +FFTGraph::on_size_request(Gtk::Requisition* requisition) +{ + width = scaleWidth + h_margin * 2; + height = scaleHeight + 2 + v_margin * 2; + + if (_logScale != 0) { + free(_logScale); + } + + _logScale = (int *) malloc(sizeof(int) * _dataSize); + //cerr << "LogScale: " << endl; + for (int i = 0; i < _dataSize; i++) { + _logScale[i] = (int)floor(log10( 1.0 + i * 9.0 / (double)_dataSize) * (double)scaleWidth); + //cerr << i << ":\t" << _logScale[i] << endl; + } + + requisition->width = width;; + requisition->height = height; +} + +void +FFTGraph::on_size_allocate(Gtk::Allocation alloc) +{ + width = alloc.get_width(); + height = alloc.get_height(); + + DrawingArea::on_size_allocate (alloc); + +} + |