//-*- C++ -*- /* * lingot, a musical instrument tuner. * * Copyright (C) 2004-2007 Ibán Cereijo Graña, Jairo Chapela Martínez. * * This file is part of lingot. * * lingot 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. * * lingot 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 lingot; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include <stdio.h> #include <math.h> #include <unistd.h> #include <signal.h> #include <string.h> #include "lingot-defs.h" #include "lingot-config.h" #include "lingot-mainframe.h" #include "lingot-config-dialog.h" #include "lingot-gauge.h" #include "lingot-i18n.h" #include "lingot-background.xpm" #include "lingot-logo.xpm" #ifdef __WIN32__ #include "windows.h" #include "shellapi.h" #include "lingot-banner.xpm" #endif void lingot_mainframe_redraw(LingotMainFrame*); void lingot_mainframe_put_frequency(LingotMainFrame*); void lingot_mainframe_draw_gauge(LingotMainFrame*); void lingot_mainframe_draw_spectrum(LingotMainFrame*); GdkColor black_color; GdkColor gauge_color; GdkColor spectrum_background_color; GdkColor spectrum_color; GdkColor noise_threshold_color; GdkColor grid_color; GdkColor freq_color; // sizes int gauge_size_x = 160; int gauge_size_y = 100; int spectrum_size_y = 64; // spectrum area margins int spectrum_bottom_margin = 16; int spectrum_top_margin = 12; int spectrum_x_margin = 15; GtkWidget* view_spectrum_item; GtkWidget* spectrum_frame; PangoFontDescription* spectrum_legend_font_desc; void lingot_mainframe_callback_redraw(GtkWidget* w, GdkEventExpose* e, LingotMainFrame* frame) { if (frame->core->running) lingot_mainframe_redraw(frame); } void lingot_mainframe_callback_destroy(GtkWidget* w, LingotMainFrame* frame) { if (frame->core->running) { g_source_remove(frame->visualization_timer_uid); g_source_remove(frame->calculation_timer_uid); g_source_remove(frame->freq_timer_uid); gtk_main_quit(); } } void lingot_mainframe_callback_about(GtkWidget* w, LingotMainFrame* frame) { if (frame->core->running) { static const gchar* authors[] = { "Ibán Cereijo Graña <ibancg@gmail.com>", "Jairo Chapela Martínez <jairochapela@gmail.com>", NULL }; const gchar* artists[] = { "Matthew Blissett (Logo design)", NULL }; gtk_show_about_dialog(NULL, "name", "Lingot", "version", VERSION REV, "copyright", "\xC2\xA9 2004-2007 Ibán Cereijo Graña\n\xC2\xA9 2004-2007 Jairo Chapela Martínez", "comments", _("Accurate and easy to use musical instrument tuner"), "authors", authors, "artists", artists, "translator-credits", _("translator-credits"), "logo-icon-name", "lingot-logo", NULL); } } void lingot_mainframe_callback_view_spectrum(GtkWidget* w, LingotMainFrame* frame) { if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(view_spectrum_item))) { gtk_widget_hide(spectrum_frame); } else { gtk_widget_show(spectrum_frame); } } void lingot_mainframe_callback_config_dialog(GtkWidget* w, LingotMainFrame* frame) { if (frame->core->running) { if (!frame->config_dialog) { frame->config_dialog = lingot_config_dialog_new(frame); } else { // TODO: activate config dialog } } } /* Callback for visualization */ gboolean lingot_mainframe_callback_visualization(gpointer data) { unsigned int period; LingotMainFrame* frame = (LingotMainFrame*) data; if (frame->core->running) { lingot_mainframe_draw_gauge(frame); period = 1000/frame->conf->visualization_rate; frame->visualization_timer_uid = g_timeout_add(period, lingot_mainframe_callback_visualization, frame); } return 0; } /* Callback for calculation */ gboolean lingot_mainframe_callback_calculation(gpointer data) { unsigned int period; LingotMainFrame* frame = (LingotMainFrame*) data; if (frame->core->running) { lingot_mainframe_draw_spectrum(frame); period = 1000/frame->conf->calculation_rate; frame->calculation_timer_uid = g_timeout_add(period, lingot_mainframe_callback_calculation, frame); } return 0; } /* Callback for frequency calculation */ gboolean lingot_mainframe_callback_frequency(gpointer data) { unsigned int period; LingotMainFrame* frame = (LingotMainFrame*) data; if (frame->core->running) { lingot_mainframe_put_frequency(frame); period = 1000/GAUGE_RATE; frame->freq_timer_uid = g_timeout_add(period, lingot_mainframe_callback_frequency, frame); } return 0; } #ifdef __WIN32__ gboolean lingot_mainframe_callback_open_url(gpointer data) { ShellExecute(NULL, "open", "http://lingot.gitara.org.pl", NULL, NULL, SW_SHOW); return 0; } #endif void lingot_mainframe_color(GdkColor* color, int red, int green, int blue) { color->red = red; color->green = green; color->blue = blue; } LingotMainFrame* lingot_mainframe_new(int argc, char *argv[]) { GtkWidget* vertical_box; GtkWidget* horizontal_box; GtkWidget* file_menu; GtkWidget* edit_menu; GtkWidget* help_menu; GtkWidget* preferences_item; GtkWidget* quit_item; GtkWidget* about_item; GtkAccelGroup* accel_group; GtkWidget* menu_bar; GtkWidget* file_item; GtkWidget* edit_item; GtkWidget* help_item; GtkWidget* frame1; GtkWidget* frame3; GtkWidget* vbinfo; LingotMainFrame* frame; unsigned int period; frame = malloc(sizeof(LingotMainFrame)); frame->config_dialog = NULL; frame->pix_stick = NULL; frame->conf = lingot_config_new(); lingot_config_load(frame->conf, CONFIG_FILE_NAME); frame->gauge = lingot_gauge_new(frame->conf->vr); // gauge in rest situation frame->core = lingot_core_new(frame->conf); // ----- FREQUENCY FILTER CONFIGURATION ------ // low pass IIR filter. FLT freq_filter_a[] = { 1.0, -0.5}; FLT freq_filter_b[] = { 0.5}; frame->freq_filter= lingot_filter_new( 1, 0, freq_filter_a, freq_filter_b); // --------------------------------------------------- gtk_init(&argc, &argv); gtk_set_locale(); // creates the window frame->win = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_position(GTK_WINDOW(frame->win), GTK_WIN_POS_CENTER); GdkPixbuf* logo = gdk_pixbuf_new_from_xpm_data(lingotlogo); gtk_icon_theme_add_builtin_icon("lingot-logo", 64, logo); gtk_window_set_icon(GTK_WINDOW(frame->win), logo); // g_object_unref(logo); gtk_window_set_title(GTK_WINDOW(frame->win), _("lingot")); gtk_container_set_border_width(GTK_CONTAINER(frame->win), 6); // fixed size gtk_window_set_resizable(GTK_WINDOW(frame->win), FALSE); // tab organization by following container vertical_box = gtk_vbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(frame->win), vertical_box); file_menu = gtk_menu_new(); edit_menu = gtk_menu_new(); help_menu = gtk_menu_new(); GtkWidget* view_menu = gtk_menu_new(); accel_group = gtk_accel_group_new(); /* menu elements */ preferences_item = gtk_image_menu_item_new_from_stock( GTK_STOCK_PREFERENCES, accel_group); quit_item = gtk_image_menu_item_new_from_stock(GTK_STOCK_QUIT, accel_group); about_item = gtk_image_menu_item_new_from_stock(GTK_STOCK_ABOUT, accel_group); view_spectrum_item= gtk_check_menu_item_new_with_label(_("Spectrum")); gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(view_spectrum_item), TRUE); /* addition */ gtk_menu_append(GTK_MENU(file_menu), quit_item); gtk_menu_append(GTK_MENU(edit_menu), preferences_item); gtk_menu_append(GTK_MENU(view_menu), view_spectrum_item); gtk_menu_append(GTK_MENU(help_menu), about_item); gtk_widget_add_accelerator(preferences_item, "activate", accel_group, 'o', GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); gtk_widget_add_accelerator(quit_item, "activate", accel_group, 'q', GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); gtk_window_add_accel_group(GTK_WINDOW(frame->win), accel_group); gtk_signal_connect(GTK_OBJECT(preferences_item), "activate", GTK_SIGNAL_FUNC(lingot_mainframe_callback_config_dialog), frame); gtk_signal_connect(GTK_OBJECT(quit_item), "activate", GTK_SIGNAL_FUNC(lingot_mainframe_callback_destroy), frame); gtk_signal_connect(GTK_OBJECT(about_item), "activate", GTK_SIGNAL_FUNC(lingot_mainframe_callback_about), frame); gtk_signal_connect(GTK_OBJECT(view_spectrum_item), "activate", GTK_SIGNAL_FUNC(lingot_mainframe_callback_view_spectrum), frame); menu_bar = gtk_menu_bar_new(); gtk_widget_show(menu_bar); gtk_box_pack_start_defaults(GTK_BOX(vertical_box), menu_bar); file_item = gtk_menu_item_new_with_mnemonic(_("_File")); edit_item = gtk_menu_item_new_with_mnemonic(_("_Edit")); GtkWidget* view_item = gtk_menu_item_new_with_mnemonic(_("_View")); help_item = gtk_menu_item_new_with_mnemonic(_("_Help")); gtk_menu_item_right_justify(GTK_MENU_ITEM(help_item)); gtk_menu_item_set_submenu(GTK_MENU_ITEM(file_item), file_menu); gtk_menu_item_set_submenu(GTK_MENU_ITEM(edit_item), edit_menu); gtk_menu_item_set_submenu(GTK_MENU_ITEM(view_item), view_menu); gtk_menu_item_set_submenu(GTK_MENU_ITEM(help_item), help_menu); gtk_menu_bar_append(GTK_MENU_BAR(menu_bar), file_item); gtk_menu_bar_append(GTK_MENU_BAR(menu_bar), edit_item); gtk_menu_bar_append(GTK_MENU_BAR(menu_bar), view_item); gtk_menu_bar_append(GTK_MENU_BAR(menu_bar), help_item); #ifdef GTK12 gtk_menu_bar_set_shadow_type( GTK_MENU_BAR (menu_bar), GTK_SHADOW_NONE ); #endif #ifdef __WIN32__ { GtkWidget *banner = gtk_button_new(); gtk_signal_connect(GTK_OBJECT(banner), "clicked", GTK_SIGNAL_FUNC(lingot_mainframe_callback_open_url), "http://gitara.org.pl"); GtkWidget *banner_image = gtk_image_new_from_pixbuf(gdk_pixbuf_new_from_xpm_data(lingot_banner_xpm)); gtk_button_set_image(banner, banner_image); gtk_box_pack_start_defaults(GTK_BOX(vertical_box), banner); } #endif //////////////////////////////////////////////////// // a fixed container to put the two upper frames in fixed positions horizontal_box = gtk_hbox_new(FALSE, 0); gtk_box_pack_start_defaults(GTK_BOX(vertical_box), horizontal_box); // gauge frame frame1 = gtk_frame_new(_("Deviation")); // gtk_fixed_put(GTK_FIXED(fix), frame1, 0, 0); gtk_box_pack_start(GTK_BOX(horizontal_box), frame1, FALSE, FALSE, 0); // note frame frame3 = gtk_frame_new(_("Note")); //gtk_fixed_put(GTK_BOX(hb), frame3, 164, 0); gtk_box_pack_start(GTK_BOX(horizontal_box), frame3, TRUE, TRUE, 0); // spectrum frame at bottom spectrum_frame = gtk_frame_new(_("Spectrum")); gtk_box_pack_end_defaults(GTK_BOX(vertical_box), spectrum_frame); // for gauge drawing frame->gauge_area = gtk_drawing_area_new(); gtk_widget_set_size_request(GTK_WIDGET(frame->gauge_area), gauge_size_x, gauge_size_y); gtk_container_add(GTK_CONTAINER(frame1), frame->gauge_area); // for spectrum drawing GtkObject* adjust = gtk_adjustment_new(0.0, 0.0, ((frame->conf->fft_size > 256) ? 0.5 : 1.0)*frame->conf->sample_rate, 1.0, 100.0, 100.0); frame->spectrum_scroll = GTK_SCROLLED_WINDOW(gtk_scrolled_window_new( GTK_ADJUSTMENT(adjust), NULL)); frame->spectrum_area = gtk_drawing_area_new(); int x = ((frame->conf->fft_size > 256) ? (frame->conf->fft_size >> 1) : 256) + 2*spectrum_x_margin; int y = spectrum_size_y + spectrum_bottom_margin + spectrum_top_margin; gtk_widget_set_size_request(GTK_WIDGET(frame->spectrum_area), x, y); gtk_scrolled_window_set_policy(frame->spectrum_scroll, (frame->conf->fft_size > 512) ? GTK_POLICY_ALWAYS : GTK_POLICY_NEVER, GTK_POLICY_NEVER); gtk_scrolled_window_add_with_viewport(frame->spectrum_scroll, frame->spectrum_area); gtk_widget_set_size_request(GTK_WIDGET(frame->spectrum_scroll), 260 + 2 *spectrum_x_margin, spectrum_size_y + spectrum_bottom_margin + spectrum_top_margin + 4 + ((frame->conf->fft_size > 512) ? 16 : 0)); gtk_container_add(GTK_CONTAINER(spectrum_frame), GTK_WIDGET(frame->spectrum_scroll)); // for note and frequency displaying vbinfo = gtk_vbox_new(FALSE, 0); gtk_widget_set_size_request(GTK_WIDGET(vbinfo), 96 + 2*spectrum_x_margin, gauge_size_y); gtk_container_add(GTK_CONTAINER(frame3), vbinfo); frame->freq_label = gtk_label_new(_("freq")); gtk_box_pack_start_defaults(GTK_BOX(vbinfo), frame->freq_label); frame->error_label = gtk_label_new(_("err")); gtk_box_pack_end_defaults(GTK_BOX(vbinfo), frame->error_label); frame->note_label = gtk_label_new(_("note")); gtk_widget_set_name(frame->note_label, "label_nota"); gtk_box_pack_end_defaults(GTK_BOX(vbinfo), frame->note_label); // show all gtk_widget_show_all(frame->win); // two pixmaps for double buffer in gauge and spectrum drawing // (virtual screen) gdk_pixmap_new(frame->gauge_area->window, gauge_size_x, gauge_size_y, -1); frame->pix_spectrum= gdk_pixmap_new(frame->spectrum_area->window, x, y, -1); // GTK signals gtk_signal_connect(GTK_OBJECT(frame->gauge_area), "expose_event", GTK_SIGNAL_FUNC(lingot_mainframe_callback_redraw), frame); gtk_signal_connect(GTK_OBJECT(frame->spectrum_area), "expose_event", GTK_SIGNAL_FUNC(lingot_mainframe_callback_redraw), frame); gtk_signal_connect(GTK_OBJECT(frame->win), "destroy", GTK_SIGNAL_FUNC(lingot_mainframe_callback_destroy), frame); period = 1000/frame->conf->visualization_rate; frame->visualization_timer_uid = g_timeout_add(period, lingot_mainframe_callback_visualization, frame); period = 1000/frame->conf->calculation_rate; frame->calculation_timer_uid = g_timeout_add(period, lingot_mainframe_callback_calculation, frame); period = 1000/GAUGE_RATE; frame->freq_timer_uid = g_timeout_add(period, lingot_mainframe_callback_frequency, frame); lingot_mainframe_color(&gauge_color, 0xC000, 0x0000, 0x2000); lingot_mainframe_color(&spectrum_background_color, 0x1111, 0x3333, 0x1111); lingot_mainframe_color(&spectrum_color, 0x2222, 0xEEEE, 0x2222); lingot_mainframe_color(&noise_threshold_color, 0x8888, 0x8888, 0x2222); lingot_mainframe_color(&grid_color, 0x9000, 0x9000, 0x9000); lingot_mainframe_color(&freq_color, 0xFFFF, 0x2222, 0x2222); gdk_color_alloc(gdk_colormap_get_system(), &gauge_color); gdk_color_alloc(gdk_colormap_get_system(), &spectrum_color); gdk_color_alloc(gdk_colormap_get_system(), &spectrum_background_color); gdk_color_alloc(gdk_colormap_get_system(), &noise_threshold_color); gdk_color_alloc(gdk_colormap_get_system(), &grid_color); gdk_color_alloc(gdk_colormap_get_system(), &freq_color); gdk_color_black(gdk_colormap_get_system(), &black_color); spectrum_legend_font_desc =pango_font_description_from_string("Helvetica Plain 7"); return frame; } void lingot_mainframe_destroy(LingotMainFrame* frame) { lingot_gauge_destroy(frame->gauge); lingot_core_destroy(frame->core); lingot_filter_destroy(frame->freq_filter); lingot_config_destroy(frame->conf); if (frame->config_dialog) lingot_config_dialog_destroy(frame->config_dialog); // pango_font_description_free(spectrum_legend_font_desc); // gtk_widget_destroy(frame->freq_label); // gtk_widget_destroy(frame->error_label); // gtk_widget_destroy(frame->note_label); // gtk_widget_destroy(frame->win); // gdk_color_free(&gauge_color); // gdk_color_free(&spectrum_color); // gdk_color_free(&spectrum_background_color); // gdk_color_free(&noise_threshold_color); // gdk_color_free(&grid_color); // gdk_color_free(&freq_color); free(frame); } void lingot_mainframe_run(LingotMainFrame* frame) { lingot_core_start(frame->core); gtk_main(); lingot_core_stop(frame->core); lingot_mainframe_destroy(frame); } // --------------------------------------------------------------------------- void lingot_mainframe_redraw(LingotMainFrame* frame) { lingot_mainframe_draw_gauge(frame); lingot_mainframe_draw_spectrum(frame); } // --------------------------------------------------------------------------- void lingot_mainframe_draw_gauge(LingotMainFrame* frame) { GdkGC* gc = frame->gauge_area->style->fg_gc[frame->gauge_area->state]; GdkWindow* w = frame->gauge_area->window; GdkGCValues gv; gdk_gc_get_values(gc, &gv); static FLT gauge_size = 90.0; FLT max = 1.0; // draws background if (!frame->pix_stick) { frame->pix_stick = gdk_pixmap_create_from_xpm_d( frame->gauge_area->window, NULL, NULL, background2_xpm); } gdk_draw_pixmap(frame->gauge_area->window, gc, frame->pix_stick, 0, 0, 0, 0, 160, 100); // and draws gauge gdk_gc_set_foreground(gc, &gauge_color); gdk_draw_line(w, gc, gauge_size_x >> 1, gauge_size_y - 1, (gauge_size_x>> 1) + (int)rint(gauge_size *sin(frame->gauge->position *M_PI/(1.5*max))), gauge_size_y - 1- (int)rint(gauge_size *cos(frame->gauge->position*M_PI /(1.5*max)))); // black edge. gdk_gc_set_foreground(gc, &black_color); gdk_draw_rectangle(w, gc, FALSE, 0, 0, gauge_size_x - 1, gauge_size_y - 1); gdk_draw_pixmap(frame->gauge_area->window, gc, w, 0, 0, 0, 0, gauge_size_x, gauge_size_y); gdk_flush(); } void lingot_mainframe_draw_spectrum(LingotMainFrame* frame) { PangoLayout* layout; int spectrum_size_x = ((frame->conf->fft_size > 256) ? (frame->conf->fft_size >> 1) : 256); // minimum grid size in pixels static int minimum_grid_width = 50; /* scale factors to draw the grid. We will choose the smaller factor that respects the minimum_grid_width */ static double scales[] = { 0.01, 0.05, 0.1, 0.2, 0.5, 1, 2, 4, 11, 22, -1.0 }; // spectrum drawing mode static gboolean spectrum_drawing_filled = TRUE; // grid division in dB static FLT grid_db_height = 25; register unsigned int i; int j; int old_j; GdkGC* gc = frame->spectrum_area->style->fg_gc[frame->spectrum_area->state]; GdkWindow* window = frame->pix_spectrum; //spectrum->window; GdkGCValues gv; gdk_gc_get_values(gc, &gv); // clear all gdk_gc_set_foreground(gc, &spectrum_background_color); gdk_draw_rectangle(window, gc, TRUE, 0, 0, spectrum_size_x + 2 *spectrum_x_margin, spectrum_size_y + spectrum_bottom_margin + spectrum_top_margin); gdk_gc_set_foreground(gc, &grid_color); gdk_draw_line(window, gc, spectrum_x_margin, spectrum_size_y + spectrum_top_margin, spectrum_x_margin + spectrum_size_x, spectrum_size_y + spectrum_top_margin); // choose scale factor for (i = 0; scales[i] > 0.0; i++) { if ((1e3*scales[i]*frame->conf->fft_size*frame->conf->oversampling /frame->conf->sample_rate) > minimum_grid_width) break; } if (scales[i] < 0.0) i--; FLT scale = scales[i]; int grid_width = 1e3*scales[i]*frame->conf->fft_size *frame->conf->oversampling/frame->conf->sample_rate; char buff[10]; FLT freq = 0.0; for (i = 0; i <= spectrum_size_x; i += grid_width) { gdk_draw_line(window, gc, spectrum_x_margin + i, spectrum_top_margin, spectrum_x_margin + i, spectrum_size_y + spectrum_top_margin + 3); if (freq == 0.0) { sprintf(buff, "0 Hz"); } else if (floor(freq) == freq) sprintf(buff, "%0.0f kHz", freq); else if (floor(10*freq) == 10*freq) { if (freq <= 1000.0) sprintf(buff, "%0.0f Hz", 1e3*freq); else sprintf(buff, "%0.1f kHz", freq); } else { if (freq <= 100.0) sprintf(buff, "%0.0f Hz", 1e3*freq); else sprintf(buff, "%0.2f kHz", freq); } layout = gtk_widget_create_pango_layout(frame->spectrum_area, buff); pango_layout_set_font_description(layout, spectrum_legend_font_desc); gdk_draw_layout(window, gc, spectrum_x_margin - 8 + i, spectrum_size_y + spectrum_top_margin + 5, layout); g_object_unref(layout); freq += scale; } # define PLOT_GAIN 8 sprintf(buff, "dB"); layout = gtk_widget_create_pango_layout(frame->spectrum_area, buff); pango_layout_set_font_description(layout, spectrum_legend_font_desc); gdk_draw_layout(window, gc, spectrum_x_margin - 6, 2, layout); g_object_unref(layout); int grid_height = (int) (PLOT_GAIN*log10(pow(10.0, grid_db_height/10.0))); // dB. j = 0; for (i = 0; i <= spectrum_size_y; i += grid_height) { if (j == 0) sprintf(buff, " %i", j); else sprintf(buff, "%i", j); layout = gtk_widget_create_pango_layout(frame->spectrum_area, buff); pango_layout_set_font_description(layout, spectrum_legend_font_desc); gdk_draw_layout(window, gc, 2, spectrum_size_y + spectrum_top_margin - i - 5, layout); g_object_unref(layout); gdk_draw_line(window, gc, spectrum_x_margin, spectrum_size_y + spectrum_top_margin - i, spectrum_x_margin + spectrum_size_x, spectrum_size_y + spectrum_top_margin - i); j += grid_db_height; } gdk_gc_set_foreground(gc, &noise_threshold_color); // noise threshold drawing. j = -1; for (i = 0; (i < frame->conf->fft_size) && (i < spectrum_size_x); i++) { if ((i % 10) > 5) continue; FLT w = 2*M_PI*i/frame->conf->fft_size; //FLT noise = pow(10.0, (frame->conf->noise_threshold_db*(1.0 - 0.9*w/M_PI))/10.0); //FLT noise = lingot_signal_get_noise_threshold(frame->conf, w); FLT noise = frame->conf->noise_threshold_nu; old_j = j; j = (noise > 1.0) ? (int) (PLOT_GAIN*log10(noise)) : 0; // dB. if ((old_j >= 0) && (old_j < spectrum_size_y)&& (j >= 0)&& (j < spectrum_size_y)) gdk_draw_line(window, gc, spectrum_x_margin + i - 1, spectrum_size_y + spectrum_top_margin - old_j, spectrum_x_margin + i, spectrum_size_y + spectrum_top_margin - j); } gdk_gc_set_foreground(gc, &spectrum_color); // spectrum drawing. j = -1; for (i = 0; (i < frame->conf->fft_size - 1) && (i < spectrum_size_x - 1); i++) { old_j = j; j = (frame->core->X[i] > 1.0) ? (int) (PLOT_GAIN*log10(frame->core->X[i])) : 0; // dB. if (spectrum_drawing_filled) { if (j < spectrum_size_y) gdk_draw_line(window, gc, spectrum_x_margin + i, spectrum_size_y + spectrum_top_margin - 1, spectrum_x_margin + i, spectrum_top_margin + ((j < spectrum_size_y) ? (spectrum_size_y - j) : 0)); } else if ((old_j >= 0) && (old_j < spectrum_size_y)&& (j >= 0)&& (j < spectrum_size_y)) gdk_draw_line(window, gc, spectrum_x_margin + i - 1, spectrum_size_y + spectrum_top_margin - old_j, spectrum_x_margin + i, spectrum_size_y + spectrum_top_margin - j); } if (frame->core->freq != 0.0) { // fundamental frequency mark with a red point. gdk_gc_set_foreground(gc, &freq_color); // index of closest sample to fundamental frequency. i = (int) rint(frame->core->freq*frame->conf->fft_size *frame->conf->oversampling/frame->conf->sample_rate); if ((i < frame->conf->fft_size - 1) && (i < spectrum_size_x - 1)) { j = (frame->core->X[i] > 1.0) ? (int) (PLOT_GAIN*log10(frame->core->X[i])) : 0; // dB. if (j < spectrum_size_y - 1) gdk_draw_rectangle(window, gc, TRUE, spectrum_x_margin + i-1, spectrum_size_y + spectrum_top_margin - j - 1, 3, 3); } } # undef PLOT_GAIN gdk_gc_set_foreground(gc, &black_color); gdk_draw_pixmap(frame->spectrum_area->window, gc, window, 0, 0, 0, 0, spectrum_size_x + 2*spectrum_x_margin, spectrum_size_y + spectrum_bottom_margin + spectrum_top_margin); gdk_flush(); } void lingot_mainframe_put_frequency(LingotMainFrame* frame) { // note indexation by semitone. static char* note_string[] = { "A", "A#", "B", "C", "C#", "D", "D#", "E", "F", "F#", "G", "G#" }; const FLT Log2 = log(2.0); FLT fret_f; int fret; char* current_note; char labeltext_current_note[100]; static char error_string[30], freq_string[30]; LingotCore* core1 = frame->core; // ignore continuous component if (isnan(frame->core->freq) || (frame->core->freq < 10.0)) { current_note = "---"; strcpy(error_string, "e = ---"); strcpy(freq_string, "f = ---"); lingot_gauge_compute(frame->gauge, frame->conf->vr); } else { // bring up some octaves to avoid negative frets. fret_f = log(frame->core->freq/frame->conf->root_frequency)/Log2*12.0 + 12e2; lingot_gauge_compute(frame->gauge, fret_f - rint(fret_f)); fret = ((int) rint(fret_f)) % 12; current_note = note_string[fret]; sprintf(error_string, "e = %+4.2f%%", frame->gauge->position*100.0); sprintf(freq_string, "f = %6.2f Hz", lingot_filter_filter_sample( frame->freq_filter, frame->core->freq)); } gtk_label_set_text(GTK_LABEL(frame->freq_label), freq_string); gtk_label_set_text(GTK_LABEL(frame->error_label), error_string); char* markup = g_markup_printf_escaped( "<span size=\"xx-large\" weight=\"bold\">%s</span>", current_note); gtk_label_set_markup(GTK_LABEL(frame->note_label), markup); g_free(markup); } void lingot_mainframe_change_config(LingotMainFrame* frame, LingotConfig* conf) { lingot_core_stop(frame->core); lingot_core_destroy(frame->core); // dup. *frame->conf = *conf; // resize spectrum area g_object_unref(frame->pix_spectrum); int x = ((frame->conf->fft_size > 256) ? (frame->conf->fft_size >> 1) : 256) + 2*spectrum_x_margin; int y = spectrum_size_y + spectrum_top_margin + spectrum_bottom_margin; gtk_widget_set_size_request(GTK_WIDGET(frame->spectrum_area), x, y); frame->pix_spectrum= gdk_pixmap_new(frame->spectrum_area->window, x, y, -1); gtk_scrolled_window_set_policy(frame->spectrum_scroll, (frame->conf->fft_size > 512) ? GTK_POLICY_ALWAYS : GTK_POLICY_NEVER, GTK_POLICY_NEVER); gtk_widget_set_size_request(GTK_WIDGET(frame->spectrum_scroll), 260 + 2 *spectrum_x_margin, spectrum_size_y + spectrum_bottom_margin + spectrum_top_margin + 4 + ((frame->conf->fft_size > 512) ? 16 : 0)); frame->core = lingot_core_new(frame->conf); lingot_core_start(frame->core); }