diff -ruN audacious-1.0.0.org/Plugins/Output/Makefile.in audacious-1.0.0/Plugins/Output/Makefile.in --- audacious-1.0.0.org/Plugins/Output/Makefile.in 2006-04-17 03:34:59.000000000 +0900 +++ audacious-1.0.0/Plugins/Output/Makefile.in 2006-04-17 19:48:34.000000000 +0900 @@ -1,5 +1,5 @@ include ../../mk/rules.mk include ../../mk/objective.mk -ALL_PLUGINS = OSS alsa disk_writer esd jack arts +ALL_PLUGINS = OSS alsa disk_writer esd jack arts crossfade SUBDIRS = @OUTPUT_PLUGINS@ diff -ruN audacious-1.0.0.org/Plugins/Output/crossfade/Makefile.in audacious-1.0.0/Plugins/Output/crossfade/Makefile.in --- audacious-1.0.0.org/Plugins/Output/crossfade/Makefile.in 1970-01-01 09:00:00.000000000 +0900 +++ audacious-1.0.0/Plugins/Output/crossfade/Makefile.in 2006-04-17 19:48:34.000000000 +0900 @@ -0,0 +1,18 @@ +include ../../../mk/rules.mk +include ../../../mk/objective.mk + +OBJECTIVE_LIBS = libcrossfade.so + +noinst_HEADERS = callbacks.h crossfade.h format.h rate.h timing.h\ + configure.h debug.h interface-2.0.h support-2.0.h volume.h\ + convert.h effect.h monitor.h support.h + +LIBDIR = $(plugindir)/$(OUTPUT_PLUGIN_DIR) + +SOURCES = callbacks.c crossfade.c monitor.c support.c\ + configure.c debug.c format.c rate.c timing.c\ + convert.c effect.c interface-2.0.c volume.c + +OBJECTS = ${SOURCES:.c=.o} + +CFLAGS += -fPIC -DPIC $(GTK_CFLAGS) -I../../.. diff -ruN audacious-1.0.0.org/Plugins/Output/crossfade/callbacks.c audacious-1.0.0/Plugins/Output/crossfade/callbacks.c --- audacious-1.0.0.org/Plugins/Output/crossfade/callbacks.c 1970-01-01 09:00:00.000000000 +0900 +++ audacious-1.0.0/Plugins/Output/crossfade/callbacks.c 2006-04-17 19:48:34.000000000 +0900 @@ -0,0 +1,37 @@ +/* + * XMMS Crossfade Plugin + * Copyright (C) 2000-2004 Peter Eisenlohr + * + * based on the original OSS Output Plugin + * Copyright (C) 1998-2000 Peter Alm, Mikael Alm, Olle Hallnas, Thomas Nilsson and 4Front Technologies + * + * 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, + * USA. + */ + +#ifdef HAVE_CONFIG_H +# include +#endif + +#include "crossfade.h" + +#include "callbacks.h" +#include "interface-2.0.h" +#include "support.h" + +void on_help_close_button_clicked(GtkButton *button, gpointer user_data) +{ + +} diff -ruN audacious-1.0.0.org/Plugins/Output/crossfade/callbacks.h audacious-1.0.0/Plugins/Output/crossfade/callbacks.h --- audacious-1.0.0.org/Plugins/Output/crossfade/callbacks.h 1970-01-01 09:00:00.000000000 +0900 +++ audacious-1.0.0/Plugins/Output/crossfade/callbacks.h 2006-04-17 19:48:34.000000000 +0900 @@ -0,0 +1,94 @@ +/* + * XMMS Crossfade Plugin + * Copyright (C) 2000-2004 Peter Eisenlohr + * + * based on the original OSS Output Plugin + * Copyright (C) 1998-2000 Peter Alm, Mikael Alm, Olle Hallnas, Thomas Nilsson and 4Front Technologies + * + * 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, + * USA. + */ + +#ifndef _CALLBACKS_H_ +#define _CALLBACKS_H_ + +#include + +/* configure.c*/ +void on_config_ok_clicked(GtkButton *button, gpointer user_data); +void on_config_apply_clicked(GtkButton *button, gpointer user_data); +void on_output_plugin_radio_toggled(GtkToggleButton *togglebutton, gpointer user_data); +void on_output_none_radio_toggled(GtkToggleButton *togglebutton, gpointer user_data); +void on_config_adevice_alt_check_toggled(GtkToggleButton *togglebutton, gpointer user_data); +void on_config_mdevice_alt_check_toggled(GtkToggleButton *togglebutton,gpointer user_data); +void on_osshwb_maxbuf_check_toggled(GtkToggleButton *togglebutton, gpointer user_data); +void on_config_crossfade_check_toggled(GtkToggleButton *togglebutton, gpointer user_data); +void on_config_mixopt_enable_check_toggled(GtkToggleButton *togglebutton, gpointer user_data); +void on_output_plugin_configure_button_clicked (GtkButton *button, gpointer user_data); +void on_output_plugin_about_button_clicked(GtkButton *button, gpointer user_data); +void on_op_throttle_check_toggled(GtkToggleButton *togglebutton, gpointer user_data); +void on_op_maxblock_check_toggled(GtkToggleButton *togglebutton, gpointer user_data); +void on_op_maxblock_spin_changed(GtkEditable *editable, gpointer user_data); +void on_op_forcereopen_check_toggled(GtkToggleButton *togglebutton, gpointer user_data); +void on_ep_configure_button_clicked(GtkButton *button, gpointer user_data); +void on_ep_about_button_clicked(GtkButton *button, gpointer user_data); +void on_ep_enable_check_toggled(GtkToggleButton *togglebutton, gpointer user_data); +void on_volnorm_enable_check_toggled(GtkToggleButton *togglebutton, gpointer user_data); +void on_xftfp_enable_check_toggled(GtkToggleButton *togglebutton, gpointer user_data); +void on_xftfp_length_spin_changed(GtkEditable *editable, gpointer user_data); +void on_xftffi_enable_check_toggled(GtkToggleButton *togglebutton, gpointer user_data); +void on_xftffi_length_spin_changed(GtkEditable *editable, gpointer user_data); +void on_xftffi_volume_spin_changed(GtkEditable *editable, gpointer user_data); +void on_pause_length_spin_changed(GtkEditable *editable, gpointer user_data); +void on_simple_length_spin_changed(GtkEditable *editable,gpointer user_data); +void on_xf_buffer_spin_changed(GtkEditable *editable, gpointer user_data); +void on_xf_autobuf_check_toggled(GtkToggleButton *togglebutton, gpointer user_data); +void on_fadeout_enable_check_toggled(GtkToggleButton *togglebutton, gpointer user_data); +void on_xfofs_none_radiobutton_toggled(GtkToggleButton *togglebutton, gpointer user_data); +void on_xfofs_none_radiobutton_clicked(GtkButton *button, gpointer user_data); +void on_xfofs_lockout_radiobutton_toggled(GtkToggleButton *togglebutton, gpointer user_data); +void on_xfofs_lockout_radiobutton_clicked(GtkButton *button, gpointer user_data); +void on_xfofs_lockin_radiobutton_toggled(GtkToggleButton *togglebutton, gpointer user_data); +void on_xfofs_lockin_radiobutton_clicked(GtkButton *button, gpointer user_data); +void on_xfofs_custom_radiobutton_toggled(GtkToggleButton *togglebutton, gpointer user_data); +void on_xfofs_custom_radiobutton_clicked(GtkButton *button, gpointer user_data); +void on_xfofs_custom_spin_changed(GtkEditable *editable, gpointer user_data); +void on_fadein_enable_check_toggled(GtkToggleButton *togglebutton, gpointer user_data); +void on_fadein_lock_check_toggled(GtkToggleButton *togglebutton, gpointer user_data); +void on_lgap_enable_check_toggled(GtkToggleButton *togglebutton, gpointer user_data); +void on_tgap_enable_check_toggled(GtkToggleButton *togglebutton, gpointer user_data); +void on_tgap_lock_check_toggled(GtkToggleButton *togglebutton, gpointer user_data); +void on_fadeout_length_spin_changed (GtkEditable *editable, gpointer user_data); +void on_fadeout_volume_spin_changed(GtkEditable *editable, gpointer user_data); +void on_fadein_length_spin_changed(GtkEditable *editable, gpointer user_data); +void on_fadein_volume_spin_changed(GtkEditable *editable, gpointer user_data); +void on_lgap_length_spin_changed(GtkEditable *editable, gpointer user_data); +void on_lgap_level_spin_changed(GtkEditable *editable, gpointer user_data); +void on_tgap_length_spin_changed(GtkEditable *editable, gpointer user_data); +void on_tgap_level_spin_changed(GtkEditable *editable, gpointer user_data); +void on_gapkiller_default_button_clicked(GtkButton *button, gpointer user_data); +void on_moth_songchange_spin_changed(GtkEditable *editable, gpointer user_data); +void on_moth_opmaxused_check_toggled(GtkToggleButton *togglebutton, gpointer user_data); +void on_misc_default_button_clicked(GtkButton *button, gpointer user_data); +void on_presets_list_click_column(GtkCList *clist, gint column, gpointer user_data); + +/* monitor.c */ +gboolean on_monitor_display_drawingarea_expose_event(GtkWidget *widget, GdkEventExpose *event, gpointer user_data); +gboolean on_monitor_win_delete_event(GtkWidget *widget, GdkEvent *event, gpointer user_data); + +/* help.c (not yet implemented) */ +void on_help_close_button_clicked(GtkButton *button, gpointer user_data); + +#endif /* _CALLBACKS_H_ */ diff -ruN audacious-1.0.0.org/Plugins/Output/crossfade/configure.c audacious-1.0.0/Plugins/Output/crossfade/configure.c --- audacious-1.0.0.org/Plugins/Output/crossfade/configure.c 1970-01-01 09:00:00.000000000 +0900 +++ audacious-1.0.0/Plugins/Output/crossfade/configure.c 2006-04-17 19:48:34.000000000 +0900 @@ -0,0 +1,1858 @@ + +/* + * XMMS Crossfade Plugin + * Copyright (C) 2000-2004 Peter Eisenlohr + * + * based on the original OSS Output Plugin + * Copyright (C) 1998-2000 Peter Alm, Mikael Alm, Olle Hallnas, Thomas Nilsson and 4Front Technologies + * + * 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, + * USA. + */ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#undef PRESET_SUPPORT + +#include "crossfade.h" +#include "configure.h" +#include "interface-2.0.h" +#include "monitor.h" +#include "support.h" + +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +#ifdef HAVE_LIBSAMPLERATE +# include +#endif + + +#define HIDE(name) \ +{ if((set_wgt = lookup_widget(config_win, name))) \ + gtk_widget_hide(set_wgt); } + +#define SHOW(name) \ +{ if((set_wgt = lookup_widget(config_win, name))) \ + gtk_widget_show(set_wgt); } + + +#define SETW_SENSITIVE(wgt, sensitive) \ + gtk_widget_set_sensitive(wgt, sensitive) + +#define SETW_TOGGLE(wgt, active) \ + gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(wgt), active) + +#define SETW_SPIN(wgt, value) \ + gtk_spin_button_set_value(GTK_SPIN_BUTTON(wgt), value) + + +#define SET_SENSITIVE(name, sensitive) \ +{ if((set_wgt = lookup_widget(config_win, name))) \ + gtk_widget_set_sensitive(set_wgt, sensitive); } + +#define SET_TOGGLE(name, active) \ +{ if((set_wgt = lookup_widget(config_win, name))) \ + gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(set_wgt), active); } + +#define SET_SPIN(name, value) \ +{ if((set_wgt = lookup_widget(config_win, name))) \ + gtk_spin_button_set_value(GTK_SPIN_BUTTON(set_wgt), value); } + +#define SET_PAGE(name, index) \ +{ if((set_wgt = lookup_widget(config_win, name))) \ + gtk_notebook_set_page(GTK_NOTEBOOK(set_wgt), index); } + +#define SET_HISTORY(name, index) \ +{ if((set_wgt = lookup_widget(config_win, name))) \ + gtk_option_menu_set_history(GTK_OPTION_MENU(set_wgt), index); } + + +#define GET_SENSITIVE(name) \ +((get_wgt = lookup_widget(config_win, name)) \ + && GTK_WIDGET_SENSITIVE(get_wgt)) \ + +#define GET_TOGGLE(name) \ +((get_wgt = lookup_widget(config_win, name)) \ + && gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(get_wgt))) + +#define GET_SPIN(name) \ +((get_wgt = lookup_widget(config_win, name)) \ + ? gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(get_wgt)) : 0) + + +static GtkWidget *config_win = NULL; +static GtkWidget *set_wgt; +static GtkWidget *get_wgt; + +/* init with DEFAULT_CFG to make sure all string pointers are set to NULL */ +static config_t _cfg = CONFIG_DEFAULT; +static config_t *cfg = &_cfg; + +/* some helpers to keep track of the GUI's state */ +static gboolean checking = FALSE; +static gint op_index; +static plugin_config_t op_config; +static gint ep_index; + + +static void update_plugin_config(gchar **config_string, gchar *name, + plugin_config_t *pc, gboolean save); + +/*****************************************************************************/ + +void g_free_f(gpointer data, gpointer user_data) +{ + g_free(data); +} + +/*****************************************************************************/ + +#ifdef PRESET_SUPPORT +static void +scan_presets(gchar *filename) +{ + struct stat stats; + FILE *fh; + gchar *data, **lines, *tmp, *name; + int i; + + if(lstat(filename, &stats)) { + DEBUG(("[crossfade] scan_presets: \"%s\":\n", filename)); + PERROR("[crossfade] scan_presets: lstat"); + return; + } + if(stats.st_size <= 0) return; + + if(!(data = g_malloc(stats.st_size + 1))) { + DEBUG(("[crossfade] scan_presets: g_malloc(%ld) failed!\n", stats.st_size)); + return; + } + + if(!(fh = fopen(filename, "r"))) { + PERROR("[crossfade] scan_presets: fopen"); + g_free(data); + return; + } + + if(fread(data, stats.st_size, 1, fh) != 1) { + DEBUG(("[crossfade] scan_presets: fread() failed!\n")); + g_free(data); + fclose(fh); + return; + } + fclose(fh); + data[stats.st_size] = 0; + + lines = g_strsplit(data, "\n", 0); + g_free(data); + + if(!lines) { + DEBUG(("[crossfade] scan_presets: g_strsplit() failed!\n")); + return; + } + + g_list_foreach(config->presets, g_free_f, NULL); + g_list_free(config->presets); + config->presets = NULL; + + for(i=0; lines[i]; i++) { + if(lines[i][0] == '[') { + if((tmp = strchr(lines[i], ']'))) { + *tmp = 0; + if((name = g_strdup(lines[i]+1))) + config->presets = g_list_append(config->presets, name); + } + } + } + + g_strfreev(lines); +} +#endif + +static void +read_fade_config(ConfigDb *db, gchar *section, gchar *key, fade_config_t *fc) +{ + gchar *s = NULL; + gint n; + + if(!db || !section || !key || !fc) return; + + bmp_cfg_db_get_string(db, section, key, &s); + if(!s) return; + + n = sscanf(s, + "%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d", + &fc->type, + &fc->pause_len_ms, + &fc->simple_len_ms, + &fc->out_enable, + &fc->out_len_ms, + &fc->out_volume, + &fc->ofs_type, + &fc->ofs_type_wanted, + &fc->ofs_custom_ms, + &fc->in_locked, + &fc->in_enable, + &fc->in_len_ms, + &fc->in_volume, + &fc->flush_pause_enable, + &fc->flush_pause_len_ms, + &fc->flush_in_enable, + &fc->flush_in_len_ms, + &fc->flush_in_volume); + + g_free(s); +} + +static void +write_fade_config(ConfigDb *db, gchar *section, gchar *key, fade_config_t *fc) +{ + gchar *s; + + if(!db || !section || !key || !fc) return; + + s = g_strdup_printf("%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d", + fc->type, + fc->pause_len_ms, + fc->simple_len_ms, + fc->out_enable, + fc->out_len_ms, + fc->out_volume, + fc->ofs_type, + fc->ofs_type_wanted, + fc->ofs_custom_ms, + fc->in_locked, + fc->in_enable, + fc->in_len_ms, + fc->in_volume, + fc->flush_pause_enable, + fc->flush_pause_len_ms, + fc->flush_in_enable, + fc->flush_in_len_ms, + fc->flush_in_volume); + + if(!s) return; + + bmp_cfg_db_set_string(db, section, key, s); + g_free(s); +} + +void +xfade_load_config() +{ +#ifdef PRESET_SUPPORT + gchar *filename; +#endif + gchar *section = "Crossfade"; + ConfigDb *db; + + db = bmp_cfg_db_open(); + + /* config items used in v0.1 */ + bmp_cfg_db_get_string(db, section, "output_plugin", &config->op_name); + bmp_cfg_db_get_string(db, section, "op_config_string", &config->op_config_string); + bmp_cfg_db_get_int(db, section, "buffer_size", &config->mix_size_ms); + bmp_cfg_db_get_int(db, section, "sync_size", &config->sync_size_ms); + bmp_cfg_db_get_int(db, section, "preload_size", &config->preload_size_ms); + bmp_cfg_db_get_int(db, section, "songchange_timeout", &config->songchange_timeout); + bmp_cfg_db_get_bool(db, section, "enable_mixer", &config->enable_mixer); + bmp_cfg_db_get_bool(db, section, "mixer_reverse", &config->mixer_reverse); + bmp_cfg_db_get_bool(db, section, "enable_debug", &config->enable_debug); + bmp_cfg_db_get_bool(db, section, "enable_monitor", &config->enable_monitor); + + /* config items introduced by v0.2 */ + bmp_cfg_db_get_bool(db, section, "gap_lead_enable", &config->gap_lead_enable); + bmp_cfg_db_get_int(db, section, "gap_lead_len_ms", &config->gap_lead_len_ms); + bmp_cfg_db_get_int(db, section, "gap_lead_level", &config->gap_lead_level); + bmp_cfg_db_get_bool(db, section, "gap_trail_enable", &config->gap_trail_enable); + bmp_cfg_db_get_int(db, section, "gap_trail_len_ms", &config->gap_trail_len_ms); + bmp_cfg_db_get_int(db, section, "gap_trail_level", &config->gap_trail_level); + bmp_cfg_db_get_int(db, section, "gap_trail_locked", &config->gap_trail_locked); + + /* config items introduced by v0.2.1 */ + bmp_cfg_db_get_bool(db, section, "buffer_size_auto", &config->mix_size_auto); + + /* config items introduced by v0.2.3 */ + bmp_cfg_db_get_bool(db, section, "album_detection", &config->album_detection); + + /* config items introduced by v0.2.4 */ + bmp_cfg_db_get_bool(db, section, "http_workaround", &config->enable_http_workaround); + bmp_cfg_db_get_bool(db, section, "enable_op_max_used", &config->enable_op_max_used); + bmp_cfg_db_get_int(db, section, "op_max_used_ms", &config->op_max_used_ms); + + /* config items introduced by v0.2.6 */ + bmp_cfg_db_get_string(db, section, "effect_plugin", &config->ep_name); + bmp_cfg_db_get_bool(db, section, "effect_enable", &config->ep_enable); + bmp_cfg_db_get_int(db, section, "output_rate", &config->output_rate); + + /* config items introduced by v0.3.0 */ + bmp_cfg_db_get_bool(db, section, "volnorm_enable", &config->volnorm_enable); + bmp_cfg_db_get_bool(db, section, "volnorm_use_qa", &config->volnorm_use_qa); + bmp_cfg_db_get_int(db, section, "volnorm_target", &config->volnorm_target); + bmp_cfg_db_get_bool(db, section, "output_keep_opened", &config->output_keep_opened); + bmp_cfg_db_get_bool(db, section, "mixer_software", &config->mixer_software); + bmp_cfg_db_get_int(db, section, "mixer_vol_left", &config->mixer_vol_left); + bmp_cfg_db_get_int(db, section, "mixer_vol_right", &config->mixer_vol_right); + + /* config items introduced by v0.3.2 */ + bmp_cfg_db_get_bool(db, section, "no_xfade_if_same_file", &config->no_xfade_if_same_file); + + /* config items introduced by v0.3.3 */ + bmp_cfg_db_get_bool(db, section, "gap_crossing", &config->gap_crossing); + + /* config items introduced by v0.3.6 */ + bmp_cfg_db_get_int(db, section, "output_quality", &config->output_quality); + + /* fade configs */ + read_fade_config(db, section, "fc_xfade", &config->fc[FADE_CONFIG_XFADE]); + read_fade_config(db, section, "fc_manual", &config->fc[FADE_CONFIG_MANUAL]); + read_fade_config(db, section, "fc_album", &config->fc[FADE_CONFIG_ALBUM]); + read_fade_config(db, section, "fc_start", &config->fc[FADE_CONFIG_START]); + read_fade_config(db, section, "fc_stop", &config->fc[FADE_CONFIG_STOP]); + read_fade_config(db, section, "fc_eop", &config->fc[FADE_CONFIG_EOP]); + read_fade_config(db, section, "fc_seek", &config->fc[FADE_CONFIG_SEEK]); + read_fade_config(db, section, "fc_pause", &config->fc[FADE_CONFIG_PAUSE]); + + bmp_cfg_db_close(db); + +#ifdef PRESET_SUPPORT + filename = g_strconcat(g_get_home_dir(), "/.audacious/xmms-crossfade-presets", NULL); + scan_presets(filename); + g_free(filename); +#endif +} + +void +xfade_save_config() +{ + gchar *section = "Crossfade"; + ConfigDb *db; + + db = bmp_cfg_db_open(); + + /* obsolete config items */ + bmp_cfg_db_unset_key(db, section, "underrun_pct"); + bmp_cfg_db_unset_key(db, section, "enable_crossfade"); + bmp_cfg_db_unset_key(db, section, "enable_gapkiller"); + bmp_cfg_db_unset_key(db, section, "mixer_use_master"); + bmp_cfg_db_unset_key(db, section, "late_effect"); + bmp_cfg_db_unset_key(db, section, "gap_lead_length"); + + /* config items used in v0.1 */ + bmp_cfg_db_set_string(db, section, "output_plugin", config->op_name ? config->op_name : DEFAULT_OP_NAME); + bmp_cfg_db_set_string(db, section, "op_config_string", config->op_config_string ? config->op_config_string : DEFAULT_OP_CONFIG_STRING); + bmp_cfg_db_set_int(db, section, "buffer_size", config->mix_size_ms); + bmp_cfg_db_set_int(db, section, "sync_size", config->sync_size_ms); + bmp_cfg_db_set_int(db, section, "preload_size", config->preload_size_ms); + bmp_cfg_db_set_int(db, section, "songchange_timeout", config->songchange_timeout); + bmp_cfg_db_set_bool(db, section, "enable_mixer", config->enable_mixer); + bmp_cfg_db_set_bool(db, section, "mixer_reverse", config->mixer_reverse); + bmp_cfg_db_set_bool(db, section, "enable_debug", config->enable_debug); + bmp_cfg_db_set_bool(db, section, "enable_monitor", config->enable_monitor); + + /* config items introduced by v0.2 */ + bmp_cfg_db_set_bool(db, section, "gap_lead_enable", config->gap_lead_enable); + bmp_cfg_db_set_int(db, section, "gap_lead_len_ms", config->gap_lead_len_ms); + bmp_cfg_db_set_int(db, section, "gap_lead_level", config->gap_lead_level); + bmp_cfg_db_set_bool(db, section, "gap_trail_enable", config->gap_trail_enable); + bmp_cfg_db_set_int(db, section, "gap_trail_len_ms", config->gap_trail_len_ms); + bmp_cfg_db_set_int(db, section, "gap_trail_level", config->gap_trail_level); + bmp_cfg_db_set_int(db, section, "gap_trail_locked", config->gap_trail_locked); + + /* config items introduced by v0.2.1 */ + bmp_cfg_db_set_bool(db, section, "buffer_size_auto", config->mix_size_auto); + + /* config items introduced by v0.2.3 */ + bmp_cfg_db_set_bool(db, section, "album_detection", config->album_detection); + + /* config items introduced by v0.2.4 */ + bmp_cfg_db_set_bool(db, section, "http_workaround", config->enable_http_workaround); + bmp_cfg_db_set_bool(db, section, "enable_op_max_used", config->enable_op_max_used); + bmp_cfg_db_set_int(db, section, "op_max_used_ms", config->op_max_used_ms); + + /* config items introduced by v0.2.6 */ + bmp_cfg_db_set_string(db, section, "effect_plugin", config->ep_name ? config->ep_name : DEFAULT_EP_NAME); + bmp_cfg_db_set_bool(db, section, "effect_enable", config->ep_enable); + bmp_cfg_db_set_int(db, section, "output_rate", config->output_rate); + + /* config items introduced by v0.3.0 */ +#ifdef VOLUME_NORMALIZER + bmp_cfg_db_set_bool(db, section, "volnorm_enable", config->volnorm_enable); + bmp_cfg_db_set_bool(db, section, "volnorm_use_qa", config->volnorm_use_qa); + bmp_cfg_db_set_int(db, section, "volnorm_target", config->volnorm_target); +#endif + bmp_cfg_db_set_bool(db, section, "output_keep_opened", config->output_keep_opened); + bmp_cfg_db_set_bool(db, section, "mixer_software", config->mixer_software); + bmp_cfg_db_set_int(db, section, "mixer_vol_left", config->mixer_vol_left); + bmp_cfg_db_set_int(db, section, "mixer_vol_right", config->mixer_vol_right); + + /* config items introduced by v0.3.2 */ + bmp_cfg_db_set_bool(db, section, "no_xfade_if_same_file",config->no_xfade_if_same_file); + + /* config items introduced by v0.3.2 */ + bmp_cfg_db_set_bool(db, section, "gap_crossing", config->gap_crossing); + + /* config items introduced by v0.3.6 */ + bmp_cfg_db_set_int(db, section, "output_quality", config->output_quality); + + /* fade configs */ + write_fade_config(db, section, "fc_xfade", &config->fc[FADE_CONFIG_XFADE]); + write_fade_config(db, section, "fc_manual", &config->fc[FADE_CONFIG_MANUAL]); + write_fade_config(db, section, "fc_album", &config->fc[FADE_CONFIG_ALBUM]); + write_fade_config(db, section, "fc_start", &config->fc[FADE_CONFIG_START]); + write_fade_config(db, section, "fc_stop", &config->fc[FADE_CONFIG_STOP]); + write_fade_config(db, section, "fc_eop", &config->fc[FADE_CONFIG_EOP]); + write_fade_config(db, section, "fc_seek", &config->fc[FADE_CONFIG_SEEK]); + write_fade_config(db, section, "fc_pause", &config->fc[FADE_CONFIG_PAUSE]); + + bmp_cfg_db_close(db); +} + +#define SAFE_FREE(x) if(x) { g_free(x); x = NULL; } +void +xfade_free_config() +{ + SAFE_FREE(cfg->op_config_string); + SAFE_FREE(cfg->op_name); + + g_list_foreach(config->presets, g_free_f, NULL); + g_list_free(config->presets); + config->presets = NULL; +} + +void +xfade_load_plugin_config(gchar *config_string, + gchar *plugin_name, + plugin_config_t *plugin_config) +{ + update_plugin_config(&config_string, plugin_name, plugin_config, FALSE); +} + +void +xfade_save_plugin_config(gchar **config_string, + gchar *plugin_name, + plugin_config_t *plugin_config) +{ + update_plugin_config(config_string, plugin_name, plugin_config, TRUE); +} + +/*** helpers *****************************************************************/ + +gint +xfade_cfg_fadeout_len(fade_config_t *fc) +{ + if(!fc) return 0; + switch(fc->type) { + case FADE_TYPE_SIMPLE_XF: + return fc->simple_len_ms; + case FADE_TYPE_ADVANCED_XF: + return fc->out_enable ? fc->out_len_ms : 0; + case FADE_TYPE_FADEOUT: + case FADE_TYPE_PAUSE_ADV: + return fc->out_len_ms; + } + return 0; +} + +gint +xfade_cfg_fadeout_volume(fade_config_t *fc) +{ + gint volume; + if(!fc) return 0; + switch(fc->type) { + case FADE_TYPE_ADVANCED_XF: + case FADE_TYPE_FADEOUT: + volume = fc->out_volume; + if(volume < 0) volume = 0; + if(volume > 100) volume = 100; + return volume; + } + return 0; +} + +gint +xfade_cfg_offset(fade_config_t *fc) +{ + if(!fc) return 0; + switch(fc->type) { + case FADE_TYPE_FLUSH: + return fc->flush_pause_enable ? fc->flush_pause_len_ms : 0; + case FADE_TYPE_PAUSE: + return fc->pause_len_ms; + case FADE_TYPE_SIMPLE_XF: + return -fc->simple_len_ms; + case FADE_TYPE_ADVANCED_XF: + switch(fc->ofs_type) { + case FC_OFFSET_LOCK_OUT: + return -fc->out_len_ms; + case FC_OFFSET_LOCK_IN: + return -fc->in_len_ms; + case FC_OFFSET_CUSTOM: + return fc->ofs_custom_ms; + } + return 0; + case FADE_TYPE_FADEOUT: + case FADE_TYPE_PAUSE_ADV: + return fc->ofs_custom_ms; + } + return 0; +} + +gint +xfade_cfg_fadein_len(fade_config_t *fc) +{ + if(!fc) return 0; + switch(fc->type) { + case FADE_TYPE_FLUSH: + return fc->flush_in_enable ? fc->flush_in_len_ms : 0; + case FADE_TYPE_SIMPLE_XF: + return fc->simple_len_ms; + case FADE_TYPE_ADVANCED_XF: + return + fc->in_locked + ? (fc->out_enable ? fc->out_len_ms : 0) + : (fc->in_enable ? fc->in_len_ms : 0); + case FADE_TYPE_FADEIN: + case FADE_TYPE_PAUSE_ADV: + return fc->in_len_ms; + } + return 0; +} + +gint +xfade_cfg_fadein_volume(fade_config_t *fc) +{ + gint volume; + if(!fc) return 0; + switch(fc->type) { + case FADE_TYPE_FLUSH: + volume = fc->flush_in_volume; + break; + case FADE_TYPE_ADVANCED_XF: + volume = fc->in_locked ? fc->out_volume : fc->in_volume; + break; + case FADE_TYPE_FADEIN: + volume = fc->in_volume; + break; + default: + volume = 0; + } + if(volume < 0) volume = 0; + if(volume > 100) volume = 100; + return volume; +} + +gboolean +xfade_cfg_gap_trail_enable(config_t *cfg) +{ + return cfg->gap_trail_locked + ? cfg->gap_lead_enable + : cfg->gap_trail_enable; +} + +gint +xfade_cfg_gap_trail_len(config_t *cfg) +{ + if(!xfade_cfg_gap_trail_enable(cfg)) return 0; + return cfg->gap_trail_locked + ? cfg->gap_lead_len_ms + : cfg->gap_trail_len_ms; +} + +gint +xfade_cfg_gap_trail_level(config_t *cfg) +{ + return cfg->gap_trail_locked + ? cfg->gap_lead_level + : cfg->gap_trail_level; +} + +gint +xfade_mix_size_ms(config_t *cfg) +{ + if(cfg->mix_size_auto) { + gint i, min_size = 0; + + for(i=0; ifc[i]); + gint offset = xfade_cfg_offset(&cfg->fc[i]); + + if(cfg->fc[i].type == FADE_TYPE_PAUSE_ADV) + size += xfade_cfg_fadein_len(&cfg->fc[i]); + + if(size < -offset) + size = -offset; + + if(size > min_size) + min_size = size; + } + return min_size += xfade_cfg_gap_trail_len(cfg) + + cfg->songchange_timeout; + } + else + return cfg->mix_size_ms; +} + +/*** internal helpers ********************************************************/ + +static void +add_menu_item(GtkWidget *menu, gchar *title, GtkSignalFunc func, gint index, gint **imap) +{ + GtkWidget *item; + if(!menu || !title || !func) return; + item = gtk_menu_item_new_with_label(title); + gtk_signal_connect(GTK_OBJECT(item), "activate", GTK_SIGNAL_FUNC(func), (gpointer)index); + gtk_widget_show(item); + gtk_menu_append(GTK_MENU(menu), item); + + if(imap) *((*imap)++) = index; +} + +/*** output method ***********************************************************/ + +/*-- callbacks --------------------------------------------------------------*/ + +static void resampling_rate_cb(GtkWidget *widget, gint index) +{ + cfg->output_rate = index; +} + +#ifdef HAVE_LIBSAMPLERATE +static void resampling_quality_cb(GtkWidget *widget, gint index) +{ + cfg->output_quality = index; +} +#endif + +/*** plugin output ***********************************************************/ + +static gchar * +strip(gchar *s) +{ + gchar *p; + if(!s) return NULL; + for(; *s == ' '; s++); + if(!*s) return s; + for(p = s+strlen(s)-1; *p == ' '; p--); + *++p = 0; + return s; +} + +static void +update_plugin_config(gchar **config_string, gchar *name, + plugin_config_t *pc, gboolean save) +{ + plugin_config_t default_pc = DEFAULT_OP_CONFIG; + + gchar *buffer = NULL; + gchar out[1024]; + + gboolean plugin_found = FALSE; + gchar *plugin, *next_plugin; + gchar *args; + + if(pc && !save) *pc = default_pc; + if(!config_string || !*config_string || !name || !pc) { + DEBUG(("[crossfade] update_plugin_config: missing arg!\n")); + return; + } + + buffer = g_strdup(*config_string); + out[0] = 0; + + for(plugin = buffer; plugin; plugin = next_plugin) { + if((next_plugin = strchr(plugin, ';'))) *next_plugin++ = 0; + if((args = strchr(plugin, '='))) *args++ = 0; + plugin = strip(plugin); + if(!*plugin || !args || !*args) continue; + + if(save) { + if(0 == strcmp(plugin, name)) continue; + if(*out) strcat(out, "; "); + strcat(out, plugin); + strcat(out, "="); + strcat(out, args); + continue; + } + else if(strcmp(plugin, name)) continue; + + args = strip(args); + sscanf(args, "%d,%d,%d,%d", + &pc->throttle_enable, + &pc->max_write_enable, + &pc->max_write_len, + &pc->force_reopen); + pc->max_write_len &= -4; + plugin_found = TRUE; + } + + if(save) { + /* only save if settings differ from defaults */ + if(( pc->throttle_enable != default_pc.throttle_enable) + ||(pc->max_write_enable != default_pc.max_write_enable) + ||(pc->max_write_len != default_pc.max_write_len) + ||(pc->force_reopen != default_pc.force_reopen)) { + if(*out) strcat(out, "; "); + sprintf(out + strlen(out), "%s=%d,%d,%d,%d", name, + pc->throttle_enable ? 1 : 0, + pc->max_write_enable ? 1 : 0, + pc->max_write_len, + pc->force_reopen); + } + if(*config_string) g_free(*config_string); + *config_string = g_strdup(out); + } + + g_free(buffer); +} + +static void +config_plugin_cb(GtkWidget *widget, gint index); + +static gint +scan_plugins(GtkWidget *option_menu, gchar *selected) +{ + GtkWidget *menu = gtk_menu_new(); + GList *list = g_list_first(get_output_list()); /* XMMS */ + gint index = 0; + gint sel_index = -1; + gint def_index = -1; + + /* sanity check */ + if(selected == NULL) selected = ""; + + /* parse module list */ + while(list) { + OutputPlugin *op = (OutputPlugin *)list->data; + GtkWidget *item = gtk_menu_item_new_with_label(op->description); + + if(op == get_crossfade_oplugin_info()) /* disable selecting ourselves */ + gtk_widget_set_sensitive(item, FALSE); + else { + if(def_index == -1) def_index = index; + if(selected && !strcmp(g_basename(op->filename), selected)) + sel_index = index; + } + + /* create menu item */ + gtk_signal_connect(GTK_OBJECT(item), "activate", + GTK_SIGNAL_FUNC(config_plugin_cb), (gpointer)index++); + gtk_widget_show(item); + gtk_menu_append(GTK_MENU(menu), item); + + /* advance to next module */ + list = g_list_next(list); + } + + /* attach menu */ + gtk_option_menu_set_menu(GTK_OPTION_MENU(option_menu), menu); + + if(sel_index == -1) { + DEBUG(("[crossfade] scan_plugins: plugin not found (\"%s\")\n", selected)); + return def_index; /* use default (first entry) */ + } + return sel_index; +} + +/*-- plugin output callbacks ------------------------------------------------*/ + +static void +config_plugin_cb(GtkWidget *widget, gint index) +{ + OutputPlugin *op = g_list_nth_data(get_output_list(), index); /* XMMS */ + + /* get plugin options from gui */ + op_config.throttle_enable = GET_TOGGLE("op_throttle_check"); + op_config.max_write_enable = GET_TOGGLE("op_maxblock_check"); + op_config.max_write_len = GET_SPIN ("op_maxblock_spin"); + op_config.force_reopen = GET_TOGGLE("op_forcereopen_check"); + + /* config -> string */ + xfade_save_plugin_config(&cfg->op_config_string, cfg->op_name, &op_config); + + /* select new plugin */ + op_index = index; + + /* get new plugin's name */ + if(cfg->op_name) g_free(cfg->op_name); + cfg->op_name = (op && op->filename) + ? g_strdup(g_basename(op->filename)) : NULL; + + /* string -> config */ + xfade_load_plugin_config(cfg->op_config_string, cfg->op_name, &op_config); + + /* update gui */ + SET_SENSITIVE("op_configure_button", op && (op->configure != NULL)); + SET_SENSITIVE("op_about_button", op && (op->about != NULL)); + SET_TOGGLE ("op_throttle_check", op_config.throttle_enable); + SET_TOGGLE ("op_maxblock_check", op_config.max_write_enable); + SET_SPIN ("op_maxblock_spin", op_config.max_write_len); + SET_SENSITIVE("op_maxblock_spin", op_config.max_write_enable); + SET_TOGGLE ("op_forcereopen_check", op_config.force_reopen); +} + +void on_output_plugin_configure_button_clicked (GtkButton *button, gpointer user_data) +{ + OutputPlugin *op = g_list_nth_data(get_output_list(), op_index); /* XMMS */ + if((op == NULL) || (op->configure == NULL)) return; + op->configure(); +} + +void on_output_plugin_about_button_clicked(GtkButton *button, gpointer user_data) +{ + OutputPlugin *op = g_list_nth_data(get_output_list(), op_index); /* XMMS */ + if((op == NULL) || (op->about == NULL)) return; + op->about(); +} + +void on_op_throttle_check_toggled(GtkToggleButton *togglebutton, gpointer user_data) +{ + op_config.throttle_enable = gtk_toggle_button_get_active(togglebutton); +} + +void on_op_maxblock_check_toggled(GtkToggleButton *togglebutton, gpointer user_data) +{ + op_config.max_write_enable = gtk_toggle_button_get_active(togglebutton); + SET_SENSITIVE("op_maxblock_spin", op_config.max_write_enable); +} + +void on_op_maxblock_spin_changed(GtkEditable *editable, gpointer user_data) +{ + op_config.max_write_len = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(editable)); +} + +void on_op_forcereopen_check_toggled(GtkToggleButton *togglebutton, gpointer user_data) +{ + op_config.max_write_enable = gtk_toggle_button_get_active(togglebutton); +} + +/*** effects *****************************************************************/ + +static void +config_effect_plugin_cb(GtkWidget *widget, gint index); + +static gint +scan_effect_plugins(GtkWidget *option_menu, gchar *selected) +{ + GtkWidget *menu = gtk_menu_new(); + GList *list = g_list_first(get_effect_list()); /* XMMS */ + gint index = 0; + gint sel_index = -1; + gint def_index = -1; + + /* sanity check */ + if(selected == NULL) selected = ""; + + /* parse module list */ + while(list) { + EffectPlugin *ep = (EffectPlugin *)list->data; + GtkWidget *item = gtk_menu_item_new_with_label(ep->description); + + if(def_index == -1) def_index = index; + if(selected && !strcmp(g_basename(ep->filename), selected)) + sel_index = index; + + /* create menu item */ + gtk_signal_connect(GTK_OBJECT(item), "activate", + GTK_SIGNAL_FUNC(config_effect_plugin_cb), (gpointer)index++); + gtk_widget_show(item); + gtk_menu_append(GTK_MENU(menu), item); + + /* advance to next module */ + list = g_list_next(list); + } + + /* attach menu */ + gtk_option_menu_set_menu(GTK_OPTION_MENU(option_menu), menu); + + if(sel_index == -1) { + DEBUG(("[crossfade] scan_effect_plugins: plugin not found (\"%s\")\n", selected)); + return def_index; /* use default (first entry) */ + } + return sel_index; +} + +/*-- plugin output callbacks ------------------------------------------------*/ + +static void +config_effect_plugin_cb(GtkWidget *widget, gint index) +{ + EffectPlugin *ep = g_list_nth_data(get_effect_list(), index); /* XMMS */ + + /* select new plugin */ + ep_index = index; + + /* get new plugin's name */ + if(cfg->ep_name) g_free(cfg->ep_name); + cfg->ep_name = (ep && ep->filename) + ? g_strdup(g_basename(ep->filename)) : NULL; + + /* update gui */ + SET_SENSITIVE("ep_configure_button", ep && (ep->configure != NULL)); + SET_SENSITIVE("ep_about_button", ep && (ep->about != NULL)); + + /* 0.3.5: apply effect config immediatelly */ + if(config->ep_name) g_free(config->ep_name); + config->ep_name = g_strdup(cfg->ep_name); + xfade_realize_ep_config(); +} + +void on_ep_configure_button_clicked(GtkButton *button, gpointer user_data) +{ + EffectPlugin *ep = g_list_nth_data(get_effect_list(), ep_index); /* XMMS */ + if((ep == NULL) || (ep->configure == NULL)) return; + ep->configure(); +} + +void on_ep_about_button_clicked(GtkButton *button, gpointer user_data) +{ + EffectPlugin *ep = g_list_nth_data(get_effect_list(), ep_index); /* XMMS */ + if((ep == NULL) || (ep->about == NULL)) return; + ep->about(); +} + +void on_ep_enable_check_toggled(GtkToggleButton *togglebutton, gpointer user_data) +{ + /* 0.3.5: apply effect config immediatelly */ + config->ep_enable = cfg->ep_enable = GET_TOGGLE("ep_enable_check"); + xfade_realize_ep_config(); +} + +/*-- volume normalizer ------------------------------------------------------*/ + +void check_effects_dependencies() +{ + if(checking) return; + checking = TRUE; + + SET_SENSITIVE("volnorm_target_spin", cfg->volnorm_enable); + SET_SENSITIVE("volnorm_target_label", cfg->volnorm_enable); + SET_SENSITIVE("volnorm_quantaudio_check", cfg->volnorm_enable); + SET_SENSITIVE("volnorm_target_spin", cfg->volnorm_enable); + + checking = FALSE; +} + +void on_volnorm_enable_check_toggled(GtkToggleButton *togglebutton, gpointer user_data) +{ + if(checking) return; + cfg->volnorm_enable = gtk_toggle_button_get_active(togglebutton); + check_effects_dependencies(); +} + +/*** crossfader **************************************************************/ + +static void xf_config_cb(GtkWidget *widget, gint index); +static void xf_type_cb (GtkWidget *widget, gint index); + +/* crude hack to keep track of menu items */ +static gint xf_config_index_map[MAX_FADE_CONFIGS]; +static gint xf_type_index_map [MAX_FADE_TYPES]; + +static void +create_crossfader_config_menu() +{ + GtkWidget *optionmenu, *menu; + gint i, *imap; + + if((optionmenu = lookup_widget(config_win, "xf_config_optionmenu"))) { + for(i=0; ifc[cfg->xf_index].type_mask; + if(mask & (1 << FADE_TYPE_REOPEN)) add_menu_item(menu, "Reopen output device", GTK_SIGNAL_FUNC(xf_type_cb), FADE_TYPE_REOPEN, &imap); + if(mask & (1 << FADE_TYPE_FLUSH)) add_menu_item(menu, "Flush output device", GTK_SIGNAL_FUNC(xf_type_cb), FADE_TYPE_FLUSH, &imap); + if(mask & (1 << FADE_TYPE_NONE)) add_menu_item(menu, "None (gapless/off)", GTK_SIGNAL_FUNC(xf_type_cb), FADE_TYPE_NONE, &imap); + if(mask & (1 << FADE_TYPE_PAUSE)) add_menu_item(menu, "Pause", GTK_SIGNAL_FUNC(xf_type_cb), FADE_TYPE_PAUSE, &imap); + if(mask & (1 << FADE_TYPE_SIMPLE_XF)) add_menu_item(menu, "Simple crossfade", GTK_SIGNAL_FUNC(xf_type_cb), FADE_TYPE_SIMPLE_XF, &imap); + if(mask & (1 << FADE_TYPE_ADVANCED_XF)) add_menu_item(menu, "Advanced crossfade", GTK_SIGNAL_FUNC(xf_type_cb), FADE_TYPE_ADVANCED_XF, &imap); + if(mask & (1 << FADE_TYPE_FADEIN)) add_menu_item(menu, "Fadein", GTK_SIGNAL_FUNC(xf_type_cb), FADE_TYPE_FADEIN, &imap); + if(mask & (1 << FADE_TYPE_FADEOUT)) add_menu_item(menu, "Fadeout", GTK_SIGNAL_FUNC(xf_type_cb), FADE_TYPE_FADEOUT, &imap); + if(mask & (1 << FADE_TYPE_PAUSE_NONE)) add_menu_item(menu, "None", GTK_SIGNAL_FUNC(xf_type_cb), FADE_TYPE_PAUSE_NONE, &imap); + if(mask & (1 << FADE_TYPE_PAUSE_ADV)) add_menu_item(menu, "Fadeout/Fadein", GTK_SIGNAL_FUNC(xf_type_cb), FADE_TYPE_PAUSE_ADV, &imap); + gtk_option_menu_set_menu(GTK_OPTION_MENU(optionmenu), menu); + } +} + +#define NONE 0x00000000L +#define XF_CONFIG 0x00000001L +#define XF_TYPE 0x00000002L +#define XF_MIX_SIZE 0x00000004L +#define XF_FADEOUT 0x00000008L +#define XF_OFFSET 0x00000010L +#define XF_FADEIN 0x00000020L +#define XF_PAGE 0x00000040L +#define XF_FLUSH 0x00000080L +#define ANY 0xffffffffL + +static void +check_crossfader_dependencies(guint32 mask) +{ + fade_config_t *fc = &cfg->fc[cfg->xf_index]; + gint i; + + /* HACK: avoid endless recursion */ + if(checking) return; + checking = TRUE; + + if(mask & XF_FLUSH) { + SET_TOGGLE ("xftfp_enable_check", fc->flush_pause_enable); + SET_SENSITIVE("xftfp_length_label", fc->flush_pause_enable); + SET_SENSITIVE("xftfp_length_spin", fc->flush_pause_enable); + SET_TOGGLE ("xftffi_enable_check", fc->flush_in_enable); + SET_SENSITIVE("xftffi_length_label", fc->flush_in_enable); + SET_SENSITIVE("xftffi_length_spin", fc->flush_in_enable); + SET_SENSITIVE("xftffi_volume_label", fc->flush_in_enable); + SET_SENSITIVE("xftffi_volume_spin", fc->flush_in_enable); + } + + if(mask & XF_MIX_SIZE) { + SET_TOGGLE ("xf_autobuf_check", cfg->mix_size_auto); + SET_SENSITIVE("xf_buffer_spin", !cfg->mix_size_auto); + SET_SPIN ("xf_buffer_spin", xfade_mix_size_ms(cfg)); + } + + if(mask & XF_CONFIG) { + for(i=0; ixf_index); i++); + if(i == MAX_FADE_CONFIGS) i=0; + SET_HISTORY("xf_config_optionmenu", i); + } + + if(mask & XF_TYPE) { + create_crossfader_type_menu(); + for(i=0; itype); i++); + if(i == MAX_FADE_TYPES) { + fc->type = FADE_TYPE_NONE; + for(i=0; itype); i++); + if(i == MAX_FADE_CONFIGS) i=0; + } + SET_HISTORY("xf_type_optionmenu", i); + } + + if(mask & XF_PAGE) { + SET_PAGE("xf_type_notebook", fc->type); + SET_SPIN("pause_length_spin", fc->pause_len_ms); + SET_SPIN("simple_length_spin", fc->simple_len_ms); + if(fc->config == FADE_CONFIG_SEEK) { + HIDE("xftf_pause_frame"); + HIDE("xftf_fadein_frame"); + } + else { + SHOW("xftf_pause_frame"); + SHOW("xftf_fadein_frame"); + } + } + + if(mask & XF_FADEOUT) { + SET_TOGGLE ("fadeout_enable_check", fc->out_enable); + SET_SENSITIVE("fadeout_length_label", fc->out_enable); + SET_SENSITIVE("fadeout_length_spin", fc->out_enable); + SET_SPIN ("fadeout_length_spin", fc->out_len_ms); + SET_SENSITIVE("fadeout_volume_label", fc->out_enable); + SET_SENSITIVE("fadeout_volume_spin", fc->out_enable); + SET_SPIN ("fadeout_volume_spin", fc->out_volume); + SET_SPIN ("xftfo_length_spin", fc->out_len_ms); + SET_SPIN ("xftfo_volume_spin", fc->out_volume); + SET_SPIN ("xftfoi_fadeout_spin", fc->out_len_ms); + } + + if(mask & XF_FADEIN) { + SET_TOGGLE ("fadein_lock_check", fc->in_locked); + SET_SENSITIVE("fadein_enable_check", !fc->in_locked); + SET_TOGGLE ("fadein_enable_check", fc->in_locked ? fc->out_enable : fc->in_enable); + SET_SENSITIVE("fadein_length_label", !fc->in_locked && fc->in_enable); + SET_SENSITIVE("fadein_length_spin", !fc->in_locked && fc->in_enable); + SET_SPIN ("fadein_length_spin", fc->in_locked ? fc->out_len_ms : fc->in_len_ms); + SET_SENSITIVE("fadein_volume_label", !fc->in_locked && fc->in_enable); + SET_SENSITIVE("fadein_volume_spin", !fc->in_locked && fc->in_enable); + SET_SPIN ("fadein_volume_spin", fc->in_locked ? fc->out_volume : fc->in_volume); + SET_SPIN ("xftfi_length_spin", fc->in_len_ms); + SET_SPIN ("xftfi_volume_spin", fc->in_volume); + SET_SPIN ("xftfoi_fadein_spin", fc->in_len_ms); + } + + if(mask & XF_OFFSET) { + if(fc->out_enable) + SET_SENSITIVE("xfofs_lockout_radiobutton", TRUE); + if(!fc->in_locked && fc->in_enable) + SET_SENSITIVE("xfofs_lockin_radiobutton", TRUE); + + switch(fc->ofs_type) { + case FC_OFFSET_LOCK_OUT: + if(!fc->out_enable) { + SET_TOGGLE("xfofs_none_radiobutton", TRUE); + fc->ofs_type = FC_OFFSET_NONE; + } + break; + case FC_OFFSET_LOCK_IN: + if(!(!fc->in_locked && fc->in_enable)) { + if((fc->in_locked && fc->out_enable)) { + SET_TOGGLE("xfofs_lockout_radiobutton", TRUE); + fc->ofs_type = FC_OFFSET_LOCK_OUT; + } else { + SET_TOGGLE("xfofs_none_radiobutton", TRUE); + fc->ofs_type = FC_OFFSET_NONE; + } + } + break; + } + + switch(fc->ofs_type_wanted) { + case FC_OFFSET_NONE: + SET_TOGGLE("xfofs_none_radiobutton", TRUE); + fc->ofs_type = FC_OFFSET_NONE; + break; + case FC_OFFSET_LOCK_OUT: + if(fc->out_enable) { + SET_TOGGLE("xfofs_lockout_radiobutton", TRUE); + fc->ofs_type = FC_OFFSET_LOCK_OUT; + } + break; + case FC_OFFSET_LOCK_IN: + if(!fc->in_locked && fc->in_enable) { + SET_TOGGLE("xfofs_lockin_radiobutton", TRUE); + fc->ofs_type = FC_OFFSET_LOCK_IN; + } + else if(fc->out_enable) { + SET_TOGGLE("xfofs_lockout_radiobutton", TRUE); + fc->ofs_type = FC_OFFSET_LOCK_OUT; + } + break; + case FC_OFFSET_CUSTOM: + SET_TOGGLE("xfofs_custom_radiobutton", TRUE); + fc->ofs_type = FC_OFFSET_CUSTOM; + break; + } + + if(!fc->out_enable) + SET_SENSITIVE("xfofs_lockout_radiobutton", FALSE); + if(!(!fc->in_locked && fc->in_enable)) + SET_SENSITIVE("xfofs_lockin_radiobutton", FALSE); + + SET_SENSITIVE("xfofs_custom_spin", fc->ofs_type == FC_OFFSET_CUSTOM); + SET_SPIN ("xfofs_custom_spin", xfade_cfg_offset(fc)); + SET_SPIN ("xftfo_silence_spin", xfade_cfg_offset(fc)); + SET_SPIN ("xftfoi_silence_spin", xfade_cfg_offset(fc)); + } + + checking = FALSE; +} + +/*-- crossfader callbacks ---------------------------------------------------*/ + +void on_xf_buffer_spin_changed(GtkEditable *editable, gpointer user_data) +{ + if(checking) return; + cfg->mix_size_ms = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(editable)); + check_crossfader_dependencies(NONE); +} + +void on_xf_autobuf_check_toggled(GtkToggleButton *togglebutton, gpointer user_data) +{ + cfg->mix_size_auto = gtk_toggle_button_get_active(togglebutton); + check_crossfader_dependencies(XF_MIX_SIZE); +} + +/* - config/type - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/ + +void xf_config_cb(GtkWidget *widget, gint index) +{ + if(checking) return; + cfg->xf_index = index; + check_crossfader_dependencies(ANY & ~XF_CONFIG); +} + +void xf_type_cb(GtkWidget *widget, gint index) +{ + if(checking) return; + cfg->fc[cfg->xf_index].type = index; + check_crossfader_dependencies(ANY & ~XF_CONFIG); +} + +/* - flush - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/ + +void on_xftfp_enable_check_toggled(GtkToggleButton *togglebutton, gpointer user_data) +{ + if(checking) return; + cfg->fc[cfg->xf_index].flush_pause_enable + = gtk_toggle_button_get_active(togglebutton); + check_crossfader_dependencies(XF_FLUSH|XF_MIX_SIZE); +} + +void on_xftfp_length_spin_changed(GtkEditable *editable, gpointer user_data) +{ + if(checking) return; + cfg->fc[cfg->xf_index].flush_pause_len_ms + = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(editable)); + check_crossfader_dependencies(XF_FLUSH); +} + +void on_xftffi_enable_check_toggled(GtkToggleButton *togglebutton, gpointer user_data) +{ + if(checking) return; + cfg->fc[cfg->xf_index].flush_in_enable + = gtk_toggle_button_get_active(togglebutton); + check_crossfader_dependencies(XF_FLUSH|XF_OFFSET|XF_FADEOUT|XF_FADEIN); +} + +void on_xftffi_length_spin_changed(GtkEditable *editable, gpointer user_data) +{ + if(checking) return; + cfg->fc[cfg->xf_index].flush_in_len_ms + = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(editable)); + check_crossfader_dependencies(XF_FLUSH); +} + +void on_xftffi_volume_spin_changed(GtkEditable *editable, gpointer user_data) +{ + if(checking) return; + cfg->fc[cfg->xf_index].flush_in_volume + = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(editable)); + check_crossfader_dependencies(XF_FLUSH); +} + +/* - pause - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/ + +void on_pause_length_spin_changed(GtkEditable *editable, gpointer user_data) +{ + if(checking) return; + cfg->fc[cfg->xf_index].pause_len_ms + = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(editable)); + check_crossfader_dependencies(XF_MIX_SIZE); +} + +/* - simple - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/ + +void on_simple_length_spin_changed(GtkEditable *editable, gpointer user_data) +{ + if(checking) return; + cfg->fc[cfg->xf_index].simple_len_ms + = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(editable)); + check_crossfader_dependencies(XF_MIX_SIZE); +} + +/* - crossfade-fadeout - - - - - - - - - - - - - - - - - - - - - - - - - - -*/ + +void on_fadeout_enable_check_toggled(GtkToggleButton *togglebutton, gpointer user_data) +{ + if(checking) return; + cfg->fc[cfg->xf_index].out_enable + = gtk_toggle_button_get_active(togglebutton); + check_crossfader_dependencies(XF_MIX_SIZE|XF_OFFSET|XF_FADEOUT|XF_FADEIN); +} + +void on_fadeout_length_spin_changed(GtkEditable *editable, gpointer user_data) +{ + if(checking) return; + cfg->fc[cfg->xf_index].out_len_ms + = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(editable)); + check_crossfader_dependencies(XF_MIX_SIZE|XF_OFFSET|XF_FADEIN); +} + +void on_fadeout_volume_spin_changed(GtkEditable *editable, gpointer user_data) +{ + cfg->fc[cfg->xf_index].out_volume + = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(editable)); + check_crossfader_dependencies(XF_OFFSET|XF_FADEIN); +} + +/* - crossfade-offset - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/ + +void on_xfofs_none_radiobutton_toggled(GtkToggleButton *togglebutton, gpointer user_data) +{ + if(checking || !gtk_toggle_button_get_active(togglebutton)) return; + cfg->fc[cfg->xf_index].ofs_type = FC_OFFSET_NONE; + cfg->fc[cfg->xf_index].ofs_type_wanted = FC_OFFSET_NONE; + check_crossfader_dependencies(XF_MIX_SIZE|XF_OFFSET); +} + +void on_xfofs_none_radiobutton_clicked(GtkButton *button, gpointer user_data) +{ + if(checking) return; + cfg->fc[cfg->xf_index].ofs_type_wanted = FC_OFFSET_NONE; +} + +void on_xfofs_lockout_radiobutton_toggled(GtkToggleButton *togglebutton, gpointer user_data) +{ + if(checking || !gtk_toggle_button_get_active(togglebutton)) return; + cfg->fc[cfg->xf_index].ofs_type = FC_OFFSET_LOCK_OUT; + cfg->fc[cfg->xf_index].ofs_type_wanted = FC_OFFSET_LOCK_OUT; + check_crossfader_dependencies(XF_MIX_SIZE|XF_OFFSET); +} + +void on_xfofs_lockout_radiobutton_clicked(GtkButton *button, gpointer user_data) +{ + if(checking) return; + cfg->fc[cfg->xf_index].ofs_type_wanted = FC_OFFSET_LOCK_OUT; +} + +void on_xfofs_lockin_radiobutton_toggled(GtkToggleButton *togglebutton, gpointer user_data) +{ + if(checking || !gtk_toggle_button_get_active(togglebutton)) return; + cfg->fc[cfg->xf_index].ofs_type = FC_OFFSET_LOCK_IN; + cfg->fc[cfg->xf_index].ofs_type_wanted = FC_OFFSET_LOCK_IN; + check_crossfader_dependencies(XF_MIX_SIZE|XF_OFFSET); +} + +void on_xfofs_lockin_radiobutton_clicked(GtkButton *button, gpointer user_data) +{ + if(checking) return; + cfg->fc[cfg->xf_index].ofs_type_wanted = FC_OFFSET_LOCK_IN; +} + +void on_xfofs_custom_radiobutton_toggled(GtkToggleButton *togglebutton, gpointer user_data) +{ + if(checking || !gtk_toggle_button_get_active(togglebutton)) return; + cfg->fc[cfg->xf_index].ofs_type = FC_OFFSET_CUSTOM; + cfg->fc[cfg->xf_index].ofs_type_wanted = FC_OFFSET_CUSTOM; + check_crossfader_dependencies(XF_MIX_SIZE|XF_OFFSET); +} + +void on_xfofs_custom_radiobutton_clicked(GtkButton *button, gpointer user_data) +{ + if(checking) return; + cfg->fc[cfg->xf_index].ofs_type_wanted = FC_OFFSET_CUSTOM; +} + +void on_xfofs_custom_spin_changed(GtkEditable *editable, gpointer user_data) +{ + if(checking) return; + cfg->fc[cfg->xf_index].ofs_custom_ms = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(editable)); + check_crossfader_dependencies(XF_MIX_SIZE); +} + +/* - crossfade-fadein - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/ + +void on_fadein_lock_check_toggled(GtkToggleButton *togglebutton, gpointer user_data) +{ + if(checking) return; + cfg->fc[cfg->xf_index].in_locked = gtk_toggle_button_get_active(togglebutton); + check_crossfader_dependencies(XF_OFFSET|XF_FADEIN); +} + +void on_fadein_enable_check_toggled(GtkToggleButton *togglebutton, gpointer user_data) +{ + if(checking) return; + cfg->fc[cfg->xf_index].in_enable = gtk_toggle_button_get_active(togglebutton); + check_crossfader_dependencies(XF_OFFSET|XF_FADEIN); +} + +void on_fadein_length_spin_changed(GtkEditable *editable, gpointer user_data) +{ + if(checking) return; + cfg->fc[cfg->xf_index].in_len_ms = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(editable)); + check_crossfader_dependencies(XF_MIX_SIZE|XF_OFFSET); +} + +void on_fadein_volume_spin_changed(GtkEditable *editable, gpointer user_data) +{ + if(checking) return; + cfg->fc[cfg->xf_index].in_volume = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(editable)); + check_crossfader_dependencies(NONE); +} + +/*-- fadein -----------------------------------------------------------------*/ + +/* signal set to on_fadein_length_spin_changed */ +/* signal set to on_fadein_volume_spin_changed */ + +/*-- fadeout ----------------------------------------------------------------*/ + +/* signal set to on_fadeout_length_spin_changed */ +/* signal set to on_fadeout_volume_spin_changed */ + +/*-- fadeout/fadein ---------------------------------------------------------*/ + +/* signal set to on_fadeout_length_spin_changed */ +/* signal set to on_xfofs_custom_spin_changed */ +/* signal set to on_fadeout_volume_spin_changed */ + +/*** gap killer **************************************************************/ + +void check_gapkiller_dependencies() +{ + if(checking) return; + checking = TRUE; + + SET_SENSITIVE("lgap_length_spin", cfg->gap_lead_enable); + SET_SENSITIVE("lgap_level_spin", cfg->gap_lead_enable); + SET_SENSITIVE("tgap_enable_check", !cfg->gap_trail_locked); + SET_SENSITIVE("tgap_length_spin", !cfg->gap_trail_locked && cfg->gap_trail_enable); + SET_SENSITIVE("tgap_level_spin", !cfg->gap_trail_locked && cfg->gap_trail_enable); + + if(cfg->gap_trail_locked) { + SET_TOGGLE("tgap_enable_check", cfg->gap_lead_enable); + SET_SPIN ("tgap_length_spin", cfg->gap_lead_len_ms); + SET_SPIN ("tgap_level_spin", cfg->gap_lead_level); + } + else { + SET_TOGGLE("tgap_enable_check", cfg->gap_trail_enable); + SET_SPIN ("tgap_length_spin", cfg->gap_trail_len_ms); + SET_SPIN ("tgap_level_spin", cfg->gap_trail_level); + } + + if(cfg->mix_size_auto) + SET_SPIN("xf_buffer_spin", xfade_mix_size_ms(cfg)); + + checking = FALSE; +} + +/*-- gapkiller callbacks ----------------------------------------------------*/ + +void on_lgap_enable_check_toggled(GtkToggleButton *togglebutton, gpointer user_data) +{ + if(checking) return; + cfg->gap_lead_enable = gtk_toggle_button_get_active(togglebutton); + check_gapkiller_dependencies(); +} + +void on_lgap_length_spin_changed(GtkEditable *editable, gpointer user_data) +{ + if(checking) return; + cfg->gap_lead_len_ms = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(editable)); + check_gapkiller_dependencies(); +} + +void on_lgap_level_spin_changed(GtkEditable *editable, gpointer user_data) +{ + if(checking) return; + cfg->gap_lead_level = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(editable)); + check_gapkiller_dependencies(); +} + +void on_tgap_lock_check_toggled(GtkToggleButton *togglebutton, gpointer user_data) +{ + if(checking) return; + cfg->gap_trail_locked = gtk_toggle_button_get_active(togglebutton); + check_gapkiller_dependencies(); +} + +void on_tgap_enable_check_toggled(GtkToggleButton *togglebutton, gpointer user_data) +{ + if(checking) return; + cfg->gap_trail_enable = gtk_toggle_button_get_active(togglebutton); + check_gapkiller_dependencies(); +} + +void on_tgap_length_spin_changed(GtkEditable *editable, gpointer user_data) +{ + if(checking) return; + cfg->gap_trail_len_ms = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(editable)); +} + +void on_tgap_level_spin_changed(GtkEditable *editable, gpointer user_data) +{ + if(checking) return; + cfg->gap_trail_level = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(editable)); +} + +/*** misc ********************************************************************/ + +void check_misc_dependencies() +{ + if(checking) return; + checking = TRUE; + + if(cfg->mix_size_auto) + SET_SPIN("xf_buffer_spin", xfade_mix_size_ms(cfg)); + + SET_SENSITIVE("moth_opmaxused_spin", cfg->enable_op_max_used); + + checking = FALSE; +} + +/*-- misc callbacks ---------------------------------------------------------*/ + +void on_config_mixopt_enable_check_toggled(GtkToggleButton *togglebutton, gpointer user_data) +{ + SET_SENSITIVE("mixopt_reverse_check", gtk_toggle_button_get_active(togglebutton)); + SET_SENSITIVE("mixopt_software_check", gtk_toggle_button_get_active(togglebutton)); +} + +void on_moth_songchange_spin_changed(GtkEditable *editable, gpointer user_data) +{ + if(checking) return; + cfg->songchange_timeout = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(editable)); + check_misc_dependencies(); +} + +void on_moth_opmaxused_check_toggled(GtkToggleButton *togglebutton, gpointer user_data) +{ + if(checking) return; + cfg->enable_op_max_used = gtk_toggle_button_get_active(togglebutton); + check_misc_dependencies(); +} + +/*** presets *****************************************************************/ + +void on_presets_list_click_column(GtkCList *clist, gint column, gpointer user_data) +{ + DEBUG(("*** column=%d\n", column)); +} + +/*** main config *************************************************************/ + +void on_config_apply_clicked(GtkButton *button, gpointer user_data) +{ + GtkWidget *widget; + + /* get current notebook page */ + if((widget = lookup_widget(config_win, "config_notebook"))) + cfg->page = gtk_notebook_get_current_page(GTK_NOTEBOOK(widget)); + + /* output method */ + + /* sample rate */ + + /* output method: plugin */ + op_config.throttle_enable = GET_TOGGLE("op_throttle_check"); + op_config.max_write_enable = GET_TOGGLE("op_maxblock_check"); + op_config.max_write_len = GET_SPIN ("op_maxblock_spin"); + op_config.force_reopen = GET_TOGGLE("op_forcereopen_check"); + + xfade_save_plugin_config(&cfg->op_config_string, cfg->op_name, &op_config); + + /* output method: none: */ + + /* effects: pre-mixing effect plugin */ + + /* effects: volume normalizer */ + cfg->volnorm_target = GET_SPIN ("volnorm_target_spin"); + cfg->volnorm_use_qa = GET_TOGGLE("volnorm_quantaudio_check"); + + /* crossfader */ + cfg->mix_size_auto = GET_TOGGLE("xf_autobuf_check"); + + /* gap killer */ + cfg->gap_lead_enable = GET_TOGGLE("lgap_enable_check"); + cfg->gap_lead_len_ms = GET_SPIN ("lgap_length_spin"); + cfg->gap_lead_level = GET_SPIN ("lgap_level_spin"); + + cfg->gap_trail_locked = GET_TOGGLE("tgap_lock_check"); + + cfg->gap_crossing = GET_TOGGLE("gadv_crossing_check"); + + /* misc */ + cfg->enable_debug = GET_TOGGLE("debug_stderr_check"); + cfg->enable_monitor = GET_TOGGLE("debug_monitor_check"); + cfg->enable_mixer = GET_TOGGLE("mixopt_enable_check"); + cfg->mixer_reverse = GET_TOGGLE("mixopt_reverse_check"); + cfg->mixer_software = GET_TOGGLE("mixopt_software_check"); + cfg->preload_size_ms = GET_SPIN ("moth_preload_spin"); + cfg->album_detection = GET_TOGGLE("noxf_album_check"); + cfg->no_xfade_if_same_file = GET_TOGGLE("noxf_samefile_check"); + cfg->enable_http_workaround = GET_TOGGLE("moth_httpworkaround_check"); + cfg->op_max_used_ms = GET_SPIN ("moth_opmaxused_spin"); + cfg->output_keep_opened = GET_TOGGLE("moth_outputkeepopened_check"); + + /* presets */ + + /* lock buffer */ + g_static_mutex_lock(&buffer_mutex); + + /* free existing strings */ + if(config->op_config_string) g_free(config->op_config_string); + if(config->op_name) g_free(config->op_name); + if(config->ep_name) g_free(config->ep_name); + + /* copy current settings (dupping the strings) */ + *config = *cfg; + config->op_config_string = g_strdup(cfg->op_config_string); + config->op_name = g_strdup(cfg->op_name); + config->ep_name = g_strdup(cfg->ep_name); + + /* tell the engine that the config has changed */ + xfade_realize_config(); + + /* unlock buffer */ + g_static_mutex_unlock(&buffer_mutex); + + /* save configuration */ + xfade_save_config(); + + /* show/hide monitor win depending on config->enable_monitor */ + xfade_check_monitor_win(); +} + +void on_config_ok_clicked(GtkButton *button, gpointer user_data) +{ + /* apply and save config */ + on_config_apply_clicked(button, user_data); + + /* close and destroy window */ + gtk_widget_destroy(config_win); +} + +void xfade_configure() +{ + GtkWidget *widget; + + if(!config_win) { + /* create */ + if(!(config_win = create_config_win())) { + DEBUG(("[crossfade] plugin_configure: error creating window!\n")); + return; + } + + /* update config_win when window is destroyed */ + gtk_signal_connect(GTK_OBJECT(config_win), "destroy", + GTK_SIGNAL_FUNC(gtk_widget_destroyed), &config_win); + + /* free any strings that might be left in our local copy of the config */ + if(cfg->op_config_string) g_free(cfg->op_config_string); + if(cfg->op_name) g_free(cfg->op_name); + if(cfg->ep_name) g_free(cfg->ep_name); + + /* copy current settings (dupping the strings) */ + *cfg = *config; + cfg->op_config_string = g_strdup(config->op_config_string); + cfg->op_name = g_strdup(config->op_name); + cfg->ep_name = g_strdup(config->ep_name); + + /* go to remembered notebook page */ + if((widget = lookup_widget(config_win, "config_notebook"))) + gtk_notebook_set_page(GTK_NOTEBOOK(widget), config->page); + + /* output: resampling rate */ + if((widget = lookup_widget(config_win, "resampling_rate_optionmenu"))) { + GtkWidget *menu = gtk_menu_new(); + GtkWidget *item; + + item = gtk_menu_item_new_with_label("44100 Hz"); + gtk_signal_connect(GTK_OBJECT(item), "activate", GTK_SIGNAL_FUNC(resampling_rate_cb), (gpointer)44100); + gtk_widget_show(item); + gtk_menu_append(GTK_MENU(menu), item); + + item = gtk_menu_item_new_with_label("48000 Hz"); + gtk_signal_connect(GTK_OBJECT(item), "activate", GTK_SIGNAL_FUNC(resampling_rate_cb), (gpointer)48000); + gtk_widget_show(item); + gtk_menu_append(GTK_MENU(menu), item); + + gtk_option_menu_set_menu(GTK_OPTION_MENU(widget), menu); + + switch(cfg->output_rate) { + default: + DEBUG(("[crossfade] plugin_configure: WARNING: invalid output sample rate (%d)!\n", cfg->output_rate)); + DEBUG(("[crossfade] plugin_configure: ... using default of 44100\n")); + cfg->output_rate = 44100; + case 44100: gtk_option_menu_set_history(GTK_OPTION_MENU(widget), 0); break; + case 48000: gtk_option_menu_set_history(GTK_OPTION_MENU(widget), 1); break; + } + } + + /* output: resampling quality (libsamplerate setting) */ +#ifdef HAVE_LIBSAMPLERATE + if((widget = lookup_widget(config_win, "resampling_quality_optionmenu"))) { + GtkWidget *menu = gtk_menu_new(); + GtkWidget *item; + + GtkTooltips *tooltips = (GtkTooltips *)gtk_object_get_data(GTK_OBJECT(config_win), "tooltips"); + + int converter_type; + const char *name, *description; + for(converter_type = 0; (name = src_get_name(converter_type)); + converter_type++) { + description = src_get_description(converter_type); + + item = gtk_menu_item_new_with_label(name); + gtk_tooltips_set_tip(tooltips, item, description, NULL); + + gtk_signal_connect(GTK_OBJECT(item), "activate", + GTK_SIGNAL_FUNC(resampling_quality_cb), (gpointer)converter_type); + gtk_widget_show(item); + gtk_menu_append(GTK_MENU(menu), item); + } + + gtk_option_menu_set_menu (GTK_OPTION_MENU(widget), menu); + gtk_option_menu_set_history(GTK_OPTION_MENU(widget), cfg->output_quality); + } +#else + HIDE("resampling_quality_hbox"); + HIDE("resampling_quality_optionmenu"); +#endif + + /* output method: plugin */ + xfade_load_plugin_config(cfg->op_config_string, cfg->op_name, &op_config); + SET_TOGGLE ("op_throttle_check", op_config.throttle_enable); + SET_TOGGLE ("op_maxblock_check", op_config.max_write_enable); + SET_SPIN ("op_maxblock_spin", op_config.max_write_len); + SET_SENSITIVE("op_maxblock_spin", op_config.max_write_enable); + SET_TOGGLE ("op_forcereopen_check", op_config.force_reopen); + + if((widget = lookup_widget(config_win, "op_plugin_optionmenu"))) { + OutputPlugin *op = NULL; + if((op_index = scan_plugins(widget, cfg->op_name)) >= 0) { + gtk_option_menu_set_history(GTK_OPTION_MENU(widget), op_index); + op = g_list_nth_data(get_output_list(), op_index); /* XMMS */ + } + SET_SENSITIVE("op_configure_button", op && (op->configure != NULL)); + SET_SENSITIVE("op_about_button", op && (op->about != NULL)); + } + + /* output method: none */ + + /* effects: pre-mixing effect plugin */ + if((widget = lookup_widget(config_win, "ep_plugin_optionmenu"))) { + EffectPlugin *ep = NULL; + if((ep_index = scan_effect_plugins(widget, cfg->ep_name)) >= 0) { + gtk_option_menu_set_history(GTK_OPTION_MENU(widget), ep_index); + ep = g_list_nth_data(get_effect_list(), ep_index); /* XMMS */ + } + SET_SENSITIVE("ep_configure_button", ep && (ep->configure != NULL)); + SET_SENSITIVE("ep_about_button", ep && (ep->about != NULL)); + SET_TOGGLE ("ep_enable_check", cfg->ep_enable); + } + + /* effects: volume normalizer */ + SET_TOGGLE("volnorm_enable_check", cfg->volnorm_enable); + SET_TOGGLE("volnorm_quantaudio_check", cfg->volnorm_use_qa); + SET_SPIN ("volnorm_target_spin", cfg->volnorm_target); + + check_effects_dependencies(); + + /* crossfader */ + create_crossfader_config_menu(); + + if((cfg->xf_index < 0) || (cfg->xf_index >= MAX_FADE_CONFIGS)) { + DEBUG(("[crossfade] plugin_configure: crossfade index out of range (%d)!\n", cfg->xf_index)); + cfg->xf_index = CLAMP(cfg->xf_index, 0, MAX_FADE_CONFIGS); + } + + check_crossfader_dependencies(ANY); + + /* gap killer */ + SET_TOGGLE ("lgap_enable_check", cfg->gap_lead_enable); + SET_SPIN ("lgap_length_spin", cfg->gap_lead_len_ms); + SET_SPIN ("lgap_level_spin", cfg->gap_lead_level); + SET_TOGGLE ("tgap_lock_check", cfg->gap_trail_locked); + SET_TOGGLE ("tgap_enable_check", cfg->gap_trail_enable); + SET_SPIN ("tgap_length_spin", cfg->gap_trail_len_ms); + SET_SPIN ("tgap_level_spin", cfg->gap_trail_level); + SET_TOGGLE ("gadv_crossing_check", cfg->gap_crossing); + + check_gapkiller_dependencies(); + + /* misc */ + SET_TOGGLE("debug_stderr_check", cfg->enable_debug); + SET_TOGGLE("debug_monitor_check", cfg->enable_monitor); + SET_TOGGLE("mixopt_enable_check", cfg->enable_mixer); + SET_TOGGLE("mixopt_reverse_check", cfg->mixer_reverse); + SET_TOGGLE("mixopt_software_check", cfg->mixer_software); + SET_SPIN ("moth_songchange_spin", cfg->songchange_timeout); + SET_SPIN ("moth_preload_spin", cfg->preload_size_ms); + SET_TOGGLE("noxf_album_check", cfg->album_detection); + SET_TOGGLE("noxf_samefile_check", cfg->album_detection); + SET_TOGGLE("moth_httpworkaround_check", cfg->enable_http_workaround); + SET_TOGGLE("moth_opmaxused_check", cfg->enable_op_max_used); + SET_SPIN ("moth_opmaxused_spin", cfg->op_max_used_ms); + SET_TOGGLE("moth_outputkeepopened_check", cfg->output_keep_opened); + + check_misc_dependencies(); + + /* presets */ + if((set_wgt = lookup_widget(config_win, "presets_list_list"))) { + GList *item; + + for(item = config->presets; item; item = g_list_next(item)) { + gchar *name = (gchar *)item->data; + gchar *text[] = {name, "Default", "No"}; + gtk_clist_append(GTK_CLIST(set_wgt), text); + } + } + + /* show window near mouse pointer */ + gtk_window_set_position(GTK_WINDOW(config_win), GTK_WIN_POS_MOUSE); + gtk_widget_show(config_win); + } + else + /* bring window to front */ + gdk_window_raise(config_win->window); +} + +void xfade_about() +{ + static GtkWidget *dialog; + + if (dialog != NULL) + return; + + dialog = xmms_show_message( + _("About crossfade"), + _("Audacious crossfading plugin\n" + "Code adapted for Audacious usage by Tony Vroon from:\n" + "XMMS Crossfade Plugin "VERSION"\n" + "Copyright (C) 2000-2004 Peter Eisenlohr \n" + "\n" + "based on the original OSS Output Plugin Copyright (C) 1998-2000\n" + "Peter Alm, Mikael Alm, Olle Hallnas, Thomas Nilsson and 4Front Technologies\n" + "\n" + "This program is free software; you can redistribute it and/or modify\n" + "it under the terms of the GNU General Public License as published by\n" + "the Free Software Foundation; either version 2 of the License, or\n" + "(at your option) any later version.\n" + "\n" + "This program is distributed in the hope that it will be useful,\n" + "but WITHOUT ANY WARRANTY; without even the implied warranty of\n" + "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n" + "GNU General Public License for more details.\n" + "\n" + "You should have received a copy of the GNU General Public License\n" + "along with this program; if not, write to the Free Software\n" + "Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,\n" + "USA."),_("OK"), FALSE, NULL, NULL); + + gtk_signal_connect(GTK_OBJECT(dialog), "destroy", + GTK_SIGNAL_FUNC(gtk_widget_destroyed), &dialog); +} diff -ruN audacious-1.0.0.org/Plugins/Output/crossfade/configure.h audacious-1.0.0/Plugins/Output/crossfade/configure.h --- audacious-1.0.0.org/Plugins/Output/crossfade/configure.h 1970-01-01 09:00:00.000000000 +0900 +++ audacious-1.0.0/Plugins/Output/crossfade/configure.h 2006-04-17 19:48:34.000000000 +0900 @@ -0,0 +1,55 @@ +/* + * XMMS Crossfade Plugin + * Copyright (C) 2000-2004 Peter Eisenlohr + * + * based on the original OSS Output Plugin + * Copyright (C) 1998-2000 Peter Alm, Mikael Alm, Olle Hallnas, Thomas Nilsson and 4Front Technologies + * + * 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, + * USA. + */ + +#ifndef _CONFIGURE_H_ +#define _CONFIGURE_H_ + +#include "crossfade.h" + +void xfade_load_config(); +void xfade_save_config(); +void xfade_free_config(); + +void xfade_load_plugin_config(gchar *config_string, gchar *plugin_name, + plugin_config_t *plugin_config); +void xfade_save_plugin_config(gchar **config_string, gchar *plugin_name, + plugin_config_t *plugin_confg); + +/* some helper functions */ +gint xfade_mix_size_ms(config_t *cfg); + +gint xfade_cfg_fadeout_len (fade_config_t *fc); +gint xfade_cfg_fadeout_volume(fade_config_t *fc); +gint xfade_cfg_offset (fade_config_t *fc); +gint xfade_cfg_fadein_len (fade_config_t *fc); +gint xfade_cfg_fadein_volume (fade_config_t *fc); + +gboolean xfade_cfg_gap_trail_enable(config_t *cfg); +gint xfade_cfg_gap_trail_len (config_t *cfg); +gint xfade_cfg_gap_trail_level (config_t *cfg); + +/* xmms callback prototypes */ +void xfade_about (); +void xfade_configure(); + +#endif /* _CONFIGURE_H_ */ diff -ruN audacious-1.0.0.org/Plugins/Output/crossfade/convert.c audacious-1.0.0/Plugins/Output/crossfade/convert.c --- audacious-1.0.0.org/Plugins/Output/crossfade/convert.c 1970-01-01 09:00:00.000000000 +0900 +++ audacious-1.0.0/Plugins/Output/crossfade/convert.c 2006-04-17 19:48:34.000000000 +0900 @@ -0,0 +1,132 @@ +/* + * XMMS Crossfade Plugin + * Copyright (C) 2000-2004 Peter Eisenlohr + * + * based on the original OSS Output Plugin + * Copyright (C) 1998-2000 Peter Alm, Mikael Alm, Olle Hallnas, Thomas Nilsson and 4Front Technologies + * + * 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, + * USA. + */ + +/* + * Convert to standard (16bit-le stereo) + */ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include +#include "convert.h" + +void +convert_init(convert_context_t *cc) +{ + memset(cc, 0, sizeof(*cc)); +} + +gint +convert_flow(convert_context_t *cc, + gpointer *buffer, + gint length, + format_t *format) +{ + gpointer data; + gint size; + gint sample_size, sample_count; + gint element_count; + gint16 *out, s; + + if(!cc) return 0; + if(length <= 0) return 0; + + /* calculate sample count */ + sample_size = format->is_8bit ? 1 : 2; + sample_count = length / sample_size; + if(sample_count == 0) return 0; + + /* calculate buffer size */ + size = sample_count * 2; + if(format->nch == 1) size *= 2; + + /* resize buffer if necessary */ + if(!cc->data || (size > cc->size)) { + if(!(data = g_realloc(cc->data, size))) { + DEBUG(("[crossfade] convert: g_realloc(%d) failed!\n", size)); + return 0; + } + cc->data = data; + cc->size = size; + } + + /* calculate number of stereo samples */ + element_count = sample_count; + if(format->nch == 2) element_count /= 2; + +#define CONVERT(x) \ + if(format->nch == 1) { \ + while(sample_count--) { s = x; *out++ = s; *out++ = s; } \ + } \ + else { \ + while(sample_count--) *out++ = x; \ + } + + out = cc->data; + if(format->is_8bit) { + if(format->is_unsigned) { + guint8 *in = *buffer; + CONVERT((gint16)(*in++ ^ 128) << 8); + } + else { + gint8 *in = *buffer; + CONVERT((gint16)*in++ << 8); + } + } + else { + if(format->is_unsigned) { + guint16 *in = *buffer; + if(format->is_swapped) { + CONVERT((gint16)(((*in & 0x00ff) << 8) | (*in >> 8)) ^ 32768); in++; + } else { + CONVERT((gint16)*in++ ^ 32768); + } + } + else { + gint16 *in = *buffer; + if(format->is_swapped) { + CONVERT(((*in & 0x00ff) << 8) | (*in >> 8)); in++; + } else { + if(format->nch == 1) { + CONVERT(*in++); + } + else memcpy(out, in, size); + } + } + } + *buffer = cc->data; + + return size; +} + +void +convert_free(convert_context_t *cc) +{ + if(cc->data) { + g_free(cc->data); + cc->data = NULL; + } +} + diff -ruN audacious-1.0.0.org/Plugins/Output/crossfade/convert.h audacious-1.0.0/Plugins/Output/crossfade/convert.h --- audacious-1.0.0.org/Plugins/Output/crossfade/convert.h 1970-01-01 09:00:00.000000000 +0900 +++ audacious-1.0.0/Plugins/Output/crossfade/convert.h 2006-04-17 19:48:34.000000000 +0900 @@ -0,0 +1,48 @@ +/* + * XMMS Crossfade Plugin + * Copyright (C) 2000-2004 Peter Eisenlohr + * + * based on the original OSS Output Plugin + * Copyright (C) 1998-2000 Peter Alm, Mikael Alm, Olle Hallnas, Thomas Nilsson and 4Front Technologies + * + * 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, + * USA. + */ + +/* + * Convert to standard (44100/16bit-le/stereo) + */ + +#ifndef __CONVERT_H__ +#define __CONVERT_H__ + +#include "crossfade.h" +#include "format.h" + +typedef struct +{ + gpointer data; + gint size; +} +convert_context_t; + +void convert_init(convert_context_t *cc); +gint convert_flow(convert_context_t *cc, + gpointer *buffer, + gint length, + format_t *format); +void convert_free(convert_context_t *cc); + +#endif /* _CONVERT_H_ */ diff -ruN audacious-1.0.0.org/Plugins/Output/crossfade/crossfade.c audacious-1.0.0/Plugins/Output/crossfade/crossfade.c --- audacious-1.0.0.org/Plugins/Output/crossfade/crossfade.c 1970-01-01 09:00:00.000000000 +0900 +++ audacious-1.0.0/Plugins/Output/crossfade/crossfade.c 2006-04-17 19:48:34.000000000 +0900 @@ -0,0 +1,2243 @@ +/* + * XMMS Crossfade Plugin + * Copyright (C) 2000-2004 Peter Eisenlohr + * + * based on the original OSS Output Plugin + * Copyright (C) 1998-2000 Peter Alm, Mikael Alm, Olle Hallnas, Thomas Nilsson and 4Front Technologies + * + * 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, + * USA. + */ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include "crossfade.h" +#include "configure.h" +#include "interface-2.0.h" +#include "monitor.h" +#include "support.h" +#include "effect.h" +#include "format.h" +#include "convert.h" +#include "rate.h" +#include "volume.h" +#include "timing.h" + +#include +#include +#include +#include + +#ifdef HAVE_DLFCN_H +# include +#endif +#include +#include +#include +#include +#include + + +#undef DEBUG_HARDCORE + +/* output plugin callback prototypes */ +static void xfade_init (); +static void xfade_set_volume (int l, int r); +static void xfade_get_volume (int *l, int *r); +static gint xfade_open_audio (AFormat fmt, int rate, int nch); +static void xfade_write_audio (void *ptr, int length); +static void xfade_close_audio (); +static void xfade_flush (int time); +static void xfade_pause (short paused); +static gint xfade_buffer_free (); +static gint xfade_buffer_playing(); +static gint xfade_written_time (); +static gint xfade_output_time (); + +/* output plugin callback table */ +static OutputPlugin xfade_op = +{ + NULL, + NULL, + "Crossfade Plugin " VERSION, + xfade_init, + NULL, + xfade_about, + xfade_configure, + xfade_get_volume, + xfade_set_volume, + xfade_open_audio, + xfade_write_audio, + xfade_close_audio, + xfade_flush, + xfade_pause, + xfade_buffer_free, + xfade_buffer_playing, + xfade_output_time, + xfade_written_time, + NULL /* we do not support effects on crossfade, too fragile */ +}; + +/* internal prototypes */ +static void load_symbols (); +static void output_list_hack(); +static gint open_output (); +static void buffer_reset (buffer_t *buf, config_t *cfg); +static void *buffer_thread_f (void *arg); +static void sync_output (); + +/* special XMMS symbols (dynamically looked up, see xfade_init) */ +static gboolean (*input_stopped_for_restart)() = NULL; /* XMMS */ + +void fini() __attribute__((destructor)); + +/* local variables */ +static gint session_id; +static gboolean realtime; +static gboolean is_http; + +static gint64 streampos; /* position within current song (input bps) */ +static gboolean playing; + gboolean opened; /* TRUE between open_ and close_audio() */ +static gboolean paused; /* TRUE: no playback (but still filling buffer) */ +static gboolean stopped; /* TRUE: stop buffer thread ASAP */ +static gboolean eop; /* TRUE: wait until buffer is empty then sync() */ + +static plugin_config_t the_op_config = DEFAULT_OP_CONFIG; + OutputPlugin *the_op = NULL; + gint the_rate = 44100; + +static gboolean input_playing = FALSE; + + gboolean output_opened = FALSE; +static gint output_flush_time = 0; + gint output_offset = 0; +static gint64 output_written = 0; + gint64 output_streampos = 0; + +static gboolean finishing = FALSE; /* TRUE after fini() has been called */ + +static gchar zero_4k[4096]; + +#ifdef VOLUME_NORMALIZER +static quantaudio_t qa, last_qa; +static gboolean have_qa = FALSE, have_last_qa = FALSE; +#endif + + +/* + * Available fade configs: + * + * fc_start: First song, only in_len and in_level are used + * fc_xfade: Automatic crossfade at end of song + * fc_album: Like xfade but for consecutive songs of the same album + * fc_manual: Manual crossfade (triggered by Next or Prev) + * fc_stop: Last song, only out_len and out_level are used + * fc_eop: Last song, only out_len and out_level are used + * + * NOTE: As of version 0.2 of xmms-crossfade, + * only xfade and manual are implemented. + * + * With version 0.2.3, fc_album has been added. + * + * With 0.2.4, all configs are implemented: + * + * Available parameters: + * + * | start | xfade | manual | album | stop | eop + * ------------+-------+-------+--------+-------+------+------ + * in_len | yes | yes | yes | no | no | no + * in_volume | yes | yes | yes | no | no | no + * offset | no | yes | yes | no | +yes | +yes + * out_len | no | yes | yes | no | yes | yes + * out_volume | no | yes | yes | no | yes | yes + * flush (*) | no | no | yes | no | yes | no + * ------------+-------+-------+--------+-------+------+------ + * + * Parameters marked with (*) are not configureable by the user + * + * The offset parameters for 'stop' and 'eop' is used to store the + * length of the additional silence to be added. It may be >= 0 only. + * + */ + +static struct timeval last_close; +static struct timeval last_write; + +static gchar *last_filename = NULL; + +static format_t in_format; +static format_t out_format; + +static buffer_t the_buffer; + buffer_t *buffer = &the_buffer; + +GStaticMutex buffer_mutex = G_STATIC_MUTEX_INIT; +static GThread *buffer_thread; + +static effect_context_t effect_context; +static convert_context_t convert_context; +static rate_context_t rate_context; +static volume_context_t volume_context; + +static config_t the_config; + config_t *config = &the_config; + config_t config_default = CONFIG_DEFAULT; + +static fade_config_t *fade_config = NULL; + + +/* this is the entry point for XMMS */ +OutputPlugin *get_oplugin_info() +{ + return &xfade_op; +} + +OutputPlugin *get_crossfade_oplugin_info() +{ + return &xfade_op; +} + +static gint +effect_list_f(gconstpointer a, gconstpointer b) +{ + EffectPlugin *ep = (EffectPlugin *)a; + gchar *name = (gchar *)b; + + return strcmp(g_basename(ep->filename), name); +} + +static gboolean +open_output_f(gpointer data) +{ + DEBUG(("[crossfade] open_output_f: pid=%d\n", getpid())); + open_output(); + return FALSE; /* FALSE = 'do not call me again' */ +} + +void +xfade_realize_ep_config() +{ + GList *list, *element; + EffectPlugin *ep = NULL; + + /* find effect plugin */ + if(config->ep_enable && config->ep_name && (list = get_effect_list())) /* XMMS */ + if((element = g_list_find_custom(list, config->ep_name, effect_list_f))) + ep = element->data; + + effect_set_plugin(&effect_context, ep); +} + +void +xfade_realize_config() /* also called by xfade_init() */ +{ + /* realize effect plugin config */ + xfade_realize_ep_config(); + +#ifdef VOLUME_NORMALIZER + /* update volume normalizer target rms */ + volume_set_target_rms(&volume_context, config->volnorm_target); +#endif + + /* 0.3.0: keep device opened */ + if(config->output_keep_opened && !output_opened) { + DEBUG(("[crossfade] realize_config: keeping output opened...\n")); + + /* HACK: avoid rate converter complaing about illegal input rate */ + /* if(!rate_context.valid || !rate_context.in_rate) + rate_config(&rate_context, out_format.rate, out_format.rate); */ + + /* 0.3.1: HACK: this will make sure that we start playing silence after startup */ + gettimeofday(&last_close, NULL); + + /* 0.3.1: HACK: Somehow, if we open output here at XMMS startup, there + will be leftover filedescriptors later when closing output again. + Opening output in a timeout function seems to work around this... */ + DEBUG(("[crossfade] realize_config: adding timeout (pid=%d)\n", getpid())); + g_timeout_add(0, open_output_f, NULL); + } +} + +static gint +output_list_f(gconstpointer a, gconstpointer b) +{ + OutputPlugin *op = (OutputPlugin *)a; + gchar *name = (gchar *)b; + + return strcmp(g_basename(op->filename), name); +} + +static OutputPlugin * +find_output() +{ + GList *list, *element; + OutputPlugin *op = NULL; + + /* find output plugin */ + if(config->op_name && (list = get_output_list())) /* XMMS */ + if((element = g_list_find_custom(list, config->op_name, output_list_f))) + op = element->data; + + if(op == &xfade_op) { + DEBUG(("[crossfade] find_output: can't use myself as output plugin!\n")); + op = NULL; + } + else if(!op) { + DEBUG(("[crossfade] find_output: could not find output plugin \"%s\"\n", + config->op_name ? config->op_name : "#NULL#")); + } + else /* ok, we have a plugin. last, get its compatibility options */ + xfade_load_plugin_config(config->op_config_string, config->op_name, + &the_op_config); + + return op; +} + +static gint +open_output() +{ + /* sanity check */ + if(output_opened) + DEBUG(("[crossfade] open_output: WARNING: output_opened=TRUE!\n")); + + /* reset output_* */ + output_opened = FALSE; + output_flush_time = 0; + output_offset = 0; + output_written = 0; + output_streampos = 0; + + /* get output plugin (this will also init the_op_config) */ + if(!(the_op = find_output())) { + DEBUG(("[crossfade] open_output: could not find any output!\n")); + return -1; + } + + /* print output plugin info */ + DEBUG(("[crossfade] open_output: using \"%s\" for output", + the_op->description ? the_op->description : "#NULL#")); + + if(realtime) + DEBUG((" (RT)")); + + if(the_op_config.throttle_enable) + DEBUG((realtime + ? " (throttled (disabled with RT))" + : " (throttled)")); + + if(the_op_config.max_write_enable) + DEBUG((" (max_write=%d)", the_op_config.max_write_len)); + + DEBUG(("\n")); + + /* setup sample rate (note that OUTPUT_RATE is #defined as the_rate) */ + the_rate = config->output_rate; + + /* setup out_format. use host byte order for easy math */ + setup_format(FMT_S16_NE, OUTPUT_RATE, OUTPUT_NCH, &out_format); + + /* force re-config of rate converter */ + if(in_format.rate == 0) /* this happens with keep_output_opened */ + rate_config(&rate_context, out_format.rate, out_format.rate, config->output_quality); + else + rate_config(&rate_context, in_format.rate, out_format.rate, config->output_quality); + + /* open plugin */ + if(!the_op->open_audio(out_format.fmt, out_format.rate, out_format.nch)) { + DEBUG(("[crossfade] open_output: open_audio() failed!\n")); + the_op = NULL; + return -1; + } + + /* clear buffer struct */ + memset(buffer, 0, sizeof(*buffer)); + + /* calculate buffer size */ + buffer->mix_size = MS2B(xfade_mix_size_ms(config)) & -4; + buffer->sync_size = MS2B(config->sync_size_ms) & -4; + buffer->preload_size = MS2B(config->preload_size_ms) & -4; + + buffer->size = (buffer->mix_size + /* mixing area */ + buffer->sync_size + /* additional sync */ + buffer->preload_size); /* preload */ + + DEBUG(("[crossfade] open_output: buffer: size=%d (%d+%d+%d=%d ms) (%d Hz)\n", + buffer->size, + B2MS(buffer->mix_size), + B2MS(buffer->preload_size), + B2MS(buffer->sync_size), + B2MS(buffer->size), + the_rate)); + + /* allocate buffer */ + if(!(buffer->data = g_malloc0(buffer->size))) { + DEBUG(("[crossfade] open_output: error allocating buffer!\n")); + the_op->close_audio(); + the_op = NULL; + return -1; + } + + /* reset buffer */ + buffer_reset(buffer, config); + + /* make sure stopped is TRUE -- otherwise the buffer thread would + * stop again immediatelly after it has been started. */ + stopped = FALSE; + + /* create and run buffer thread */ + buffer_thread = g_thread_create((GThreadFunc)buffer_thread_f, NULL, FALSE, NULL); + if (buffer_thread == NULL) { + PERROR("[crossfade] open_output: g_thread_create()"); + g_free(buffer->data); + the_op->close_audio(); + the_op = NULL; + return -1; + } + + /* start updating monitor */ + xfade_start_monitor(); + + /* done */ + output_opened = TRUE; + return 0; +} + +static void +xfade_init() +{ + /* load config */ + memset(config, 0, sizeof(*config)); + *config = config_default; + xfade_load_config(); + + /* set default strings if there is no existing config */ + if(!config->op_config_string) + config->op_config_string = g_strdup(DEFAULT_OP_CONFIG_STRING); + if(!config->op_name) + config->op_name = g_strdup(DEFAULT_OP_NAME); + + /* check for realtime priority, it needs some special attention */ + realtime = xmms_check_realtime_priority(); + + /* show monitor win if enabled in config */ + xfade_check_monitor_win(); + + /* init contexts */ + effect_init(&effect_context, NULL); + convert_init(&convert_context); + rate_init(&rate_context); + volume_init(&volume_context); + + /* reset */ + stopped = FALSE; + + /* find current output plugin early so that volume control works + * even if playback has not started yet. */ + if(!(the_op = find_output())) + DEBUG(("[crossfade] init: could not find any output!\n")); + + /* get xmms controlsocket session id */ + session_id = ctrlsocket_get_session_id(); + + /* load any dynamic linked symbols */ + load_symbols(); + + /* HACK: make sure we are at the beginning of XMMS' output plugin list */ + output_list_hack(); + + /* realize config -- will also setup the pre-mixing effect plugin */ + xfade_realize_config(); +} + +static void load_symbols() +{ +#ifdef HAVE_DLFCN_H + void *handle; + char *error; + + /* open ourselves (that is, the XMMS binary) */ + handle = dlopen(NULL, RTLD_NOW); + if(!handle) { + DEBUG(("[crossfade] init: dlopen(NULL) failed!\n")); + return; + } + + /* check for XMMS patches */ + DEBUG(("[crossfade] load_symbols: input_stopped_for_restart:")); + input_stopped_for_restart = dlsym(handle, "input_stopped_for_restart"); + DEBUG((!(error = dlerror()) ? " found\n" : " not found\n")); + + DEBUG(("[crossfade] load_symbols: playlist_get_info_going:")); + xmms_playlist_get_info_going = dlsym(handle, "playlist_get_info_going"); + DEBUG((!(error = dlerror()) ? " found\n" : " not found\n")); + + DEBUG(("[crossfade] load_symbols: is_quitting:")); + xmms_is_quitting = dlsym(handle, "is_quitting"); + DEBUG((!(error = dlerror()) ? " found\n" : " not found\n")); + + dlclose(handle); +#endif +} + +/* + HACK: Try to move ourselves to the beginning of XMMS output plugin list, + so that we will be freed first when XMMS is quitting. This way, we + avoid the segfault when using ALSA as the output plugin. +*/ +static void output_list_hack() +{ + GList *output_list = get_output_list(); + + int i0 = g_list_index(output_list, &xfade_op), i1; + + GList *first = g_list_first(output_list); + GList *xfade = g_list_find (output_list, &xfade_op); + xfade->data = first->data; + first->data = &xfade_op; + + i1 = g_list_index(output_list, &xfade_op); + if (i0 != i1) + DEBUG(("[crossfade] output_list_hack: crossfade moved from index %d to %d\n", i0, i1)); +} + +void fini() +{ + DEBUG(("[crossfade]\n")); + DEBUG(("[crossfade] fini: cleanup:\n")); + + /* wait for buffer_thread to stop */ + g_static_mutex_lock(&buffer_mutex); + + /* reset last_close so that the buffer thread will + * not unnecessarily wait for a timeout. */ + memset(&last_close, 0, sizeof(last_close)); + + /* HACK: tell buffer thread not to close output by itself */ + finishing = TRUE; + paused = FALSE; + + /* wait for buffer thread to clean up and terminate */ + DEBUG(("[crossfade] fini: cleanup: waiting for buffer thread...\n")); + while(output_opened && finishing) { + g_static_mutex_unlock(&buffer_mutex); + xmms_usleep(10000); + g_static_mutex_lock(&buffer_mutex); + } + DEBUG(("[crossfade] fini: cleanup: waiting for buffer thread... done\n")); + + /* HACK: 0.3.5: close output plugin from THIS thread */ +#if 0 + if(output_opened) { + DEBUG(("[crossfade] fini: cleanup: closing audio...\n")); + if(the_op->close_audio) the_op->close_audio(); + DEBUG(("[crossfade] fini: cleanup: closing audio... done\n")); + g_free(buffer->data); + output_opened = FALSE; + } +#endif + DEBUG(("[crossfade] fini: cleanup: done\n")); + + g_static_mutex_unlock (&buffer_mutex); + + /* free contexts */ + volume_free(&volume_context); + rate_free(&rate_context); + convert_free(&convert_context); + effect_free(&effect_context); + + /* save configuration (required only for mixer_vol_*) */ + xfade_save_config(); + + /* free resources */ + if(config->op_name) g_free(config->op_name); + xfade_free_config(); + if(last_filename) g_free(last_filename); + + DEBUG(("[crossfade] fini: done.\n")); +} + +void +xfade_get_volume(int *l, int *r) +{ + if(config->mixer_software) { + if(config->mixer_reverse) { + *l = config->mixer_vol_right; + *r = config->mixer_vol_left; + } else { + *l = config->mixer_vol_left; + *r = config->mixer_vol_right; + } + } + else { + if(the_op && the_op->get_volume) { + if(config->mixer_reverse) + the_op->get_volume(r, l); + else + the_op->get_volume(l, r); + } + } +} + +void +xfade_set_volume(int l, int r) +{ + if(!config->enable_mixer) return; + if(config->mixer_software) { + if(config->mixer_reverse) { + config->mixer_vol_right = l; + config->mixer_vol_left = r; + } + else { + config->mixer_vol_right = r; + config->mixer_vol_left = l; + } + } + else { + if(the_op && the_op->set_volume) { + if(config->mixer_reverse) + the_op->set_volume(r, l); + else + the_op->set_volume(l, r); + } + } +} + +/*** buffer stuff ***********************************************************/ + +static void +buffer_mfg_reset(buffer_t *buf, config_t *cfg) +{ + buf->mix = 0; + buf->fade = 0; + buf->gap = (cfg->gap_lead_enable ? MS2B(cfg->gap_lead_len_ms) & -4 : 0); + buf->gap_len = buf->gap; + buf->gap_level = cfg->gap_lead_level; + buf->gap_killed = 0; +} + +static void +buffer_reset(buffer_t *buf, config_t *cfg) +{ + buffer_mfg_reset(buf, cfg); + + buf->rd_index = 0; + buf->used = 0; + buf->preload = buf->preload_size; + + buf->silence = 0; + buf->silence_len = 0; + buf->reopen = -1; + buf->pause = -1; +} + +/****************************************************************************/ + +static void +xfade_apply_fade_config(fade_config_t *fc) +{ + gint avail, out_len, in_len, offset, skip; + gint index, length, fade, n; + gfloat out_scale, in_scale; + gboolean out_len_clipped = FALSE, offset_clipped = FALSE; + + /* Overwrites mix and fade; may add silence */ + + /* + * Example 1: offset < 0 --> mix streams together + * Example 2: offset > 0 --> insert pause between streams + * + * |----- out_len -----| * |out_len| + * | | * | | + * ~~~~~-_ /T~~~~~~~T~~ * ~~~~~\ | /T~~ + * ~-_ / | | * \ | / | + * ~-_/ | | * \ | / | + * /~-_| | * \ | / | + * / T-_ | * \ | / | + * / | ~-_ | * \ | / | + * _________/______|_____~-|__ * ___________\__________/______|__ + * |in_len| | * | |in_len| + * |<-- offset ---| * |offset-->| + * + * a) avail: max(0, used - preload) + * b) out_len: 0 .. avail + * c) in_len: 0 .. # + * d) offset: -avail .. buffer->mix_size - out_size + * e) skip: min(used, preload) + * + */ + + out_scale = 1.0f - (gfloat)xfade_cfg_fadeout_volume(fc) / 100.0f; + in_scale = 1.0f - (gfloat)xfade_cfg_fadein_volume (fc) / 100.0f; + + /* rules (see above) */ + /* a */ + avail = buffer->used - buffer->preload_size; + if(avail < 0) avail = 0; + + /* b */ + out_len = MS2B(xfade_cfg_fadeout_len(fc)) & -4; + if(out_len < 0) out_len = 0; + if(out_len > avail) { + DEBUG(("[crossfade] apply_fade_config: WARNING: clipping out_len (%d -> %d)!\n", + B2MS(out_len), B2MS(avail))); + out_len = avail; + out_len_clipped = TRUE; + } + + /* c */ + in_len = MS2B(xfade_cfg_fadein_len(fc)) & -4; + if(in_len < 0) in_len = 0; + + /* d */ + offset = MS2B(xfade_cfg_offset(fc)) & -4; + if(offset < -avail) { + DEBUG(("[crossfade] apply_fade_config: WARNING: clipping offset (%d -> %d)!\n", + B2MS(offset), -B2MS(avail))); + offset = -avail; + offset_clipped = TRUE; + } + if(offset > (buffer->mix_size - out_len)) + offset = buffer->mix_size - out_len; + + /* e */ + skip = buffer->preload_size; + if(skip > buffer->used) skip = buffer->used; + + /* cut off rest of stream (decreases latency on manual songchange) */ + if(fc->flush) { + gint cutoff = avail - MAX(out_len, -offset); /* MAX() -> glib.h */ + if(cutoff > 0) { + DEBUG(("[crossfade] apply_fade_config: %d ms flushed\n", B2MS(cutoff))); + buffer->used -= cutoff; + avail -= cutoff; + } + + /* make sure there is no pending silence */ + buffer->silence = 0; + buffer->silence_len = 0; + } + + /* begin modifying buffer at index */ + index = (buffer->rd_index + buffer->used - out_len) % buffer->size; + + /* fade out (modifies buffer directly) */ + fade = 0; + length = out_len; + while(length > 0) { + gint16 *p = (gint16 *)((gchar *)(buffer->data) + index); //yaz + gint blen = buffer->size - index; + if(blen > length) blen = length; + + for(n = blen/4; n > 0; n--) { + gfloat factor = 1.0f - (((gfloat)fade / out_len) * out_scale); + *p = (gfloat)*p * factor; p++; + *p = (gfloat)*p * factor; p++; + fade += 4; + } + + index = (index + blen) % buffer->size; + length -= blen; + } + + /* Initialize fadein. Note that the actual fading / mixing will be done + * on-the-fly when audio data is received by xfade_write_audio() */ + + /* start fading in */ + if(in_len > 0) { + buffer->fade = in_len; + buffer->fade_len = in_len; + buffer->fade_scale = in_scale; + } + else + buffer->fade = 0; + + /* start mixing */ + if(offset < 0) { + length = -offset; + buffer->mix = length; + buffer->used -= length; + } + else + buffer->mix = 0; + + /* start silence if applicable (will be applied in buffer_thread_f) */ + if(offset > 0) { + if((buffer->silence > 0) || (buffer->silence_len > 0)) + DEBUG(("[crossfade] apply_config: WARNING: silence in progress (%d/%d ms)\n", + B2MS(buffer->silence), B2MS(buffer->silence_len))); + + buffer->silence = buffer->used; + buffer->silence_len = offset; + } + + /* done */ + DEBUG(("[crossfade] apply_fade_config: avail=%d out=%d in=%d offset=%d skip=%d\n", + B2MS(avail), B2MS(out_len), B2MS(in_len), B2MS(offset), B2MS(skip))); +} + +static gint +extract_track(gchar *name) +{ + /* Remove all but numbers. + * Will not work if a filename has number in the title, like "track-03-U2.mp3" + * Ideally, should look into id3 track entry and fallback to filename + * */ + + gchar temp[8]; + int t = 0 ; + + memset(temp,0,sizeof(temp)); + while(*name != '\0' && t < sizeof(temp)) { + if(strcmp(name,"mp3") == 0) + break; + if(isdigit(*name)) + temp[t++] = *name; + name++; + } + return atoi(temp); +} + +static gint +album_match(gchar *old, gchar *new) +{ + gchar *old_dir, *new_dir; + gboolean same_dir; + gint old_track = 0, new_track = 0; + + if(!old || !new) return 0; + + old_dir = g_dirname(old); + new_dir = g_dirname(new); + same_dir = !strcmp(old_dir, new_dir); + g_free(old_dir); + g_free(new_dir); + + if(!same_dir) { + DEBUG(("[crossfade] album_match: " + "no match (different dirs)\n")); + return 0; + } + + old_track = extract_track(g_path_get_basename(old)); + new_track = extract_track(g_path_get_basename(new)); + + if(new_track <= 0) { + DEBUG(("[crossfade] album_match: can't parse track number:\n")); + DEBUG(("[crossfade] album_match: ... \"%s\"\n", g_basename(new))); + return 0; + } + + if((old_track < 0) || (old_track+1 != new_track)) { + DEBUG(("[crossfade] album_match: " + "no match (same dir, but non-successive (%d, %d))\n", + old_track, new_track)); + return 0; + } + + DEBUG(("[crossfade] album_match: " + "match detected (same dir, successive tracks (%d, %d))\n", + old_track, new_track)); + + return old_track; +} + +static gint +xfade_open_audio(AFormat fmt, int rate, int nch) +{ + gint pos; + gchar *file; + + struct timeval tv; + glong dt; + + DEBUG(("[crossfade]\n")); + DEBUG(("[crossfade] open_audio: XMMS-crossfade "VERSION"\n")); + +#if 0 + DEBUG(("[crossfade] open_audio: pid=%d\n", getpid())); +#endif + + /* sanity... don't do anything about it */ + if(opened) + DEBUG(("[crossfade] open_audio: WARNING: already opened!\n")); + + /* get filename */ +#ifdef HAVE_PLAYLIST_GET_FILENAME + pos = get_playlist_position(); /* XMMS */ + file = playlist_get_filename(pos); /* XMMS */ +#else + pos = xmms_remote_get_playlist_pos (session_id); + file = xmms_remote_get_playlist_file(session_id, pos); +#endif + DEBUG(("[crossfade] open_audio: bname=\"%s\"\n", g_basename(file))); + + /* is this an automatic crossfade? */ + if(last_filename && (fade_config == &config->fc[FADE_CONFIG_XFADE])) { + /* check if next song is the same as the current one */ + if(config->no_xfade_if_same_file && !strcmp(last_filename, file)) { + DEBUG(("[crossfade] open_audio: same file, disabling crossfade\n")); + fade_config = &config->fc[FADE_CONFIG_ALBUM]; + } + + /* check if next song is the next song from the same album */ + else if(config->album_detection && album_match(last_filename, file)) { + gboolean use_fc_album = FALSE; + + if(xfade_cfg_gap_trail_enable(config)) { + DEBUG(("[crossfade] album_match: " + "trailing gap: length=%d/%d ms\n", + B2MS(buffer->gap_killed), B2MS(buffer->gap_len))); + + if(buffer->gap_killed < buffer->gap_len) { + DEBUG(("[crossfade] album_match: " + "trailing gap: -> no silence, probably pre-faded\n")); + use_fc_album = TRUE; + } + else { + DEBUG(("[crossfade] album_match: " + "trailing gap: -> silence, sticking to XFADE\n")); + } + } + else { + DEBUG(("[crossfade] album_match: " + "trailing gap killer disabled\n")); + use_fc_album = TRUE; + } + + if(use_fc_album) { + DEBUG(("[crossfade] album_match: " + "-> using FADE_CONFIG_ALBUM\n")); + fade_config = &config->fc[FADE_CONFIG_ALBUM]; + } + } + g_free(last_filename); + } + last_filename = g_strdup(file); + +#if 0 + /* FIXME: finish this */ + /* Check if this is a short song. */ + if(fade_config == &config->fc[FADE_CONFIG_XFADE]) { + DEBUG(("*** XFADE:\n")); + int current_length = playlist_get_current_length(); + DEBUG(("*** length=%d\n", current_length)); + if (current_length < 30*1000) + fade_config = &config->fc[FADE_CONFIG_ALBUM]; + } +#endif + +#ifdef VOLUME_NORMALIZER + /* turn off volume normalizing per default, until we get a target RMS for this song */ + volume_set_active(&volume_context, FALSE); + + /* thomas: add support for quantaudio per-song mixing info */ + if(config->volnorm_use_qa) { + /* remember timing info from last song */ + last_qa = qa; + have_last_qa = have_qa; + + /* try to read quantaudio comment from ID3v1 tag */ + have_qa = get_timing_comment(file, &qa); + if(have_qa) { + DEBUG(("[crossfade] open_audio: quantaudio comment found:\n")); + DEBUG(("[crossfade] open_audio: ... RMS=%d, mix_in=%.2f, mix_out=%.2f, length=%.2f\n", + qa.RMS, qa.mix_in, qa.mix_out, qa.length)); + volume_set_song_rms(&volume_context, qa.RMS); + volume_set_active (&volume_context, TRUE); + } + else + DEBUG(("[crossfade] open_audio: no quantaudio comment found\n")); + +#if 0 + /* configure fade_config with fadeout from last song and fadein from new song */ + if(fade_config) { + config->fc[FADE_CONFIG_TIMING].out_enable = fade_config->out_enable; + config->fc[FADE_CONFIG_TIMING].out_volume = fade_config->out_volume; + config->fc[FADE_CONFIG_TIMING].out_len_ms = fade_config->out_len_ms; + config->fc[FADE_CONFIG_TIMING].ofs_custom_ms = 0; + config->fc[FADE_CONFIG_TIMING].in_enable = fade_config->in_enable; + config->fc[FADE_CONFIG_TIMING].in_volume = fade_config->in_volume; + config->fc[FADE_CONFIG_TIMING].in_len_ms = fade_config->in_len_ms; + + if(have_last_qa && ((fade_config->config == FADE_CONFIG_XFADE) || + (fade_config->config == FADE_CONFIG_ALBUM))) { + fade_config = &config->fc[FADE_CONFIG_TIMING]; + fade_config->out_enable = TRUE; + fade_config->out_volume = 0; + fade_config->out_len_ms = (gint)((last_qa.length - last_qa.mix_out) * 1000); + fade_config->ofs_custom_ms = - fade_config->out_len_ms; /* FIXME: */ + DEBUG(("[crossfade] open_audio: CONFIG_TIMING: using last song's fadeout parameter\n")); + } + + if(have_qa && ((fade_config->config == FADE_CONFIG_XFADE) || + (fade_config->config == FADE_CONFIG_ALBUM) || + (fade_config->config == FADE_CONFIG_MANUAL))) { + fade_config = &config->fc[FADE_CONFIG_TIMING]; + fade_config->in_enable = TRUE; + fade_config->in_volume = 0; + fade_config->in_len_ms = (gint)(qa.mix_in * 1000); + DEBUG(("[crossfade] open_audio: CONFIG_TIMING: using new song's fadein parameter\n")); + } + } +#endif + } + else have_qa = FALSE; + /* thomas: end */ + + if(volume_context.active && config->volnorm_enable) + DEBUG(("[crossfade] open_audio: volume normalizer: factor=%.3f\n", + volume_context.factor)); +#endif + + /* check for HTTP streaming */ + if(config->enable_http_workaround && (0 == strncasecmp(file, "http://", 7))) { + DEBUG(("[crossfade] open_audio: HTTP underrun workaround enabled.\n")); + is_http = TRUE; + } + else + is_http = FALSE; + + /* lock buffer */ + g_static_mutex_lock(&buffer_mutex); + + /* reset writer timeout */ + gettimeofday(&last_write, NULL); + + /* calculate time since last close() (don't care about overflows at 24h) */ + if(output_opened) { + gettimeofday(&tv, NULL); + dt = (tv.tv_sec - last_close.tv_sec) * 1000 + + (tv.tv_usec - last_close.tv_usec) / 1000; + } + else + dt = 0; + + DEBUG(("[crossfade] open_audio: fmt=%s rate=%d nch=%d dt=%ld ms\n", + format_name(fmt), rate, nch, dt)); + + /* check format */ + if(setup_format(fmt, rate, nch, &in_format) < 0) { + DEBUG(("[crossfade] open_audio: format not supported!\n")); + return 0; + } + + /* (re)open the device if necessary */ + if(!output_opened) { + if(open_output()) { + DEBUG(("[crossfade] open_audio: error opening/configuring output!\n")); + g_static_mutex_unlock(&buffer_mutex); + return 0; + } + fade_config = &config->fc[FADE_CONFIG_START]; + } + + /* reset */ + streampos = 0; + playing = TRUE; + opened = TRUE; + paused = FALSE; + + /* reset mix/fade/gap */ + buffer_mfg_reset(buffer, config); + + /* enable gap killer / zero crossing only for automatic/album songchange */ + switch(fade_config->config) { + case FADE_CONFIG_XFADE: + case FADE_CONFIG_ALBUM: + break; + default:; + buffer->gap = GAP_SKIPPING_DONE; + } + + /* restart realtime throttling */ + output_written = 0; + + /* start mixing */ + switch(fade_config ? fade_config->type : -1) { + case FADE_TYPE_FLUSH: + DEBUG(("[crossfade] open_audio: FLUSH:\n")); + + /* flush output plugin */ + the_op->flush(0); + output_streampos = 0; + + /* flush buffer */ + buffer_reset(buffer, config); + + /* apply fade config (pause/fadein after flush) */ + xfade_apply_fade_config(fade_config); + + /* also repopen device (if configured so in the plugin compat. options) */ + if(the_op_config.force_reopen) { + buffer->reopen = 0; + buffer->reopen_sync = FALSE; + } + break; + + case FADE_TYPE_REOPEN: + DEBUG(("[crossfade] open_audio: REOPEN:\n")); + + /* flush buffer if applicable */ + if(fade_config->flush) + buffer_reset(buffer, config); + + if(buffer->reopen >= 0) + DEBUG(("[crossfade] open_audio: REOPEN: WARNING: reopen in progress (%d ms)\n", + B2MS(buffer->reopen))); + + /* start reopen countdown (will be executed in buffer_thread_f) */ + buffer->reopen = buffer->used; /* may be 0 */ + buffer->reopen_sync = FALSE; + break; + + case FADE_TYPE_NONE: + case FADE_TYPE_PAUSE: + case FADE_TYPE_SIMPLE_XF: + case FADE_TYPE_ADVANCED_XF: + case FADE_TYPE_FADEIN: + case FADE_TYPE_FADEOUT: + DEBUG(("[crossfade] open_audio: XFADE:\n")); + + /* apply fade config (do fadeout, init mix/fade/gap, add silence) */ + xfade_apply_fade_config(fade_config); + + /* set reopen countdown. after buffer_thread_f has written + * buffer->reopen bytes, it will close/reopen the output plugin. */ + if(the_op_config.force_reopen && !(fade_config->config == FADE_CONFIG_START)) { + if(buffer->reopen >= 0) + DEBUG(("[crossfade] open_audio: XFADE: WARNING: reopen in progress (%d ms)\n", + B2MS(buffer->reopen))); + buffer->reopen = buffer->used; + buffer->reopen_sync = TRUE; + } + break; + } + + /* calculate offset of the output plugin */ + output_offset = the_op->written_time() + B2MS(buffer->used) + B2MS(buffer->silence_len); + + /* unlock buffer */ + g_static_mutex_unlock(&buffer_mutex); + + /* done */ + return 1; +} + +void +xfade_write_audio(void *ptr, int length) +{ + gint free; + gint ofs = 0; + format_t format; + +#ifdef DEBUG_HARDCORE + // yaz: XXX 64bit environment + DEBUG(("[crossfade] write_audio: ptr=0x%08lx, length=%d\n", (long)ptr, length)); +#endif + + /* sanity */ + if(length <= 0) return; + if(length & 3) { + DEBUG(("[crossfade] write_audio: truncating %d bytes!\n", length & 3)); + length &= -4; + } + + /* update input accumulator (using input format size) */ + streampos += length; + + /* apply pre-mixing effect (NOTE: format might change!) */ + format_copy(&format, &in_format); + length = effect_flow(&effect_context, (gpointer*)&ptr, length, &format, TRUE); + + /* convert sample format (signed-16bit-ne 44100hz stereo) */ + length = convert_flow(&convert_context, (gpointer*)&ptr, length, &format); + + /* convert rate */ + if(!rate_context.valid || (rate_context.in_rate != format.rate)) + rate_config(&rate_context, format.rate, out_format.rate, config->output_quality); + + length = rate_flow(&rate_context, (gpointer*)&ptr, length); + +#ifdef VOLUME_NORMALIZER + /* normalize volume */ + if(config->volnorm_enable) + volume_flow(&volume_context, (gpointer*)&ptr, length); +#endif + + /* lock buffer */ + g_static_mutex_lock(&buffer_mutex); + + /* check if device has been closed, reopen if necessary */ + if(!output_opened) { + if(open_output()) { + DEBUG(("[crossfade] write_audio: reopening failed!\n")); + g_static_mutex_unlock(&buffer_mutex); + return; + } + } + + /* reset timeout */ + gettimeofday(&last_write, NULL); + + /* calculate free buffer space, check for overflow (should never happen :) */ + free = buffer->size - buffer->used; + if(length > free) { + DEBUG(("[crossfade] write_audio: %d bytes truncated!\n", length-free)); + length = free; + } + + /* kill leading gap */ + if((length > 0) && (buffer->gap > 0)) { + gint blen = MIN(length, buffer->gap); + gint16 *p = ptr; + gint index = 0; + + gint16 left, right; + while(index < blen) { + left = *p++, right = *p++; + if(ABS(left) >= buffer->gap_level) break; + if(ABS(right) >= buffer->gap_level) break; + index += 4; + } + + buffer->gap -= index; + length -= index; + ptr = (gchar *)ptr + index; //yaz + + if((index < blen) || (buffer->gap <= 0)) { + buffer->gap_killed = buffer->gap_len - buffer->gap; + buffer->gap = 0; + + DEBUG(("[crossfade] write_audio: leading gap size: %d/%d ms\n", + B2MS(buffer->gap_killed), B2MS(buffer->gap_len))); + + /* fix streampos */ + streampos -= (gint64)buffer->gap_killed * in_format.bps / out_format.bps; + } + } + + /* start skipping to next crossing (if enabled) */ + if(buffer->gap == 0) { + if(config->gap_crossing) { + buffer->gap = GAP_SKIPPING_POSITIVE; + buffer->gap_skipped = 0; + } + else + buffer->gap = GAP_SKIPPING_DONE; + } + + /* skip until next zero crossing (pos -> neg) */ + if((length > 0) && (buffer->gap == GAP_SKIPPING_POSITIVE)) { + gint16 *p = ptr; + gint index = 0; + + gint16 left; + while(index < length) { + left = *p++; p++; + if(left < 0) break; + index += 4; + } + + buffer->gap_skipped += index; + length -= index; + ptr = (gchar *)ptr + index; //yaz + + if(index < length) + buffer->gap = GAP_SKIPPING_NEGATIVE; + } + + /* skip until next zero crossing (neg -> pos) */ + if((length > 0) && (buffer->gap == GAP_SKIPPING_NEGATIVE)) { + gint16 *p = ptr; + gint index = 0; + + gint16 left; + while(index < length) { + left = *p++; p++; + if(left >= 0) break; + index += 4; + } + + buffer->gap_skipped += index; + length -= index; + ptr = (gchar *)ptr + index; //yaz + + if(index < length) { + DEBUG(("[crossfade] write_audio: %d samples to next crossing\n", + buffer->gap_skipped)); + buffer->gap = GAP_SKIPPING_DONE; + } + } + + /* update preload. the buffer thread will not write any + * data to the device before preload is decreased below 1. */ + if((length > 0) && (buffer->preload > 0)) + buffer->preload -= length; + + /* fadein -- FIXME: is modifying the input/effect buffer safe? */ + if((length > 0) && (buffer->fade > 0)) { + gint16 *p = ptr; + gint blen = MIN(length, buffer->fade); + gint n; + + for(n = blen/4; n > 0; n--) { + gfloat factor = 1.0f - (((gfloat)buffer->fade / buffer->fade_len) * buffer->fade_scale); + *p = (gfloat)*p * factor; p++; + *p = (gfloat)*p * factor; p++; + buffer->fade -= 4; + } + } + + /* mix */ + while((length > 0) && (buffer->mix > 0)) { + gint wr_index = (buffer->rd_index + buffer->used) % buffer->size; + gint blen = buffer->size - wr_index; + gint16 *p1 = (gint16 *)((gchar *)(buffer->data) + wr_index); //yaz + gint16 *p2 = (gint16 *)((gchar *)ptr + ofs); //yaz + gint n; + + if(blen > length) blen = length; + if(blen > buffer->mix) blen = buffer->mix; + + for(n = blen/2; n > 0; n--) { + gint out = (gint)*p1 + *p2++; /* add */ + if(out > 32767) /* clamp */ + *p1++ = 32767; + else if(out < -32768) + *p1++ = -32768; + else + *p1++ = out; + } + + buffer->used += blen; + buffer->mix -= blen; + length -= blen; + ofs += blen; + } + + /* normal write */ + while(length > 0) { + gint wr_index = (buffer->rd_index + buffer->used) % buffer->size; + gint blen = buffer->size - wr_index; + + if(blen > length) blen = length; + + memcpy((gchar *)(buffer->data) + wr_index, (gchar *)ptr + ofs, blen); //yaz + + buffer->used += blen; + length -= blen; + ofs += blen; + } + + /* unlock buffer */ + g_static_mutex_unlock(&buffer_mutex); +#ifdef DEBUG_HARDCORE + DEBUG(("[crossfade] write_audio: done.\n")); +#endif +} + +/* sync_output: wait for output plugin to finish playback */ +/* is only called from within buffer_thread_f */ +static void sync_output() +{ + glong dt, total; + gint opt, opt_last; + struct timeval tv, tv_start, tv_last_change; + gboolean was_closed = !opened; + + if(!the_op->buffer_playing || !the_op->buffer_playing()) { + DEBUG(("[crossfade] sync_output: nothing to do\n")); + return; + } + + DEBUG(("[crossfade] sync_output: waiting for plugin...\n")); + + dt = 0; + opt_last = 0; + gettimeofday(&tv_start, NULL); + gettimeofday(&tv_last_change, NULL); + + while((dt < SYNC_OUTPUT_TIMEOUT) + && !stopped + && output_opened + && !(was_closed && opened) + && the_op && the_op->buffer_playing()) { + + /* use output_time() to check if the output plugin is still active */ + if(the_op->output_time) { + opt = the_op->output_time(); + if(opt != opt_last) { + /* output_time has changed */ + opt_last = opt; + gettimeofday(&tv_last_change, NULL); + } + else { + /* calculate time since last change of the_op->output_time() */ + gettimeofday(&tv, NULL); + dt = (tv.tv_sec - tv_last_change.tv_sec) * 1000 + + (tv.tv_usec - tv_last_change.tv_usec) / 1000; + } + } + + /* yield */ + g_static_mutex_unlock(&buffer_mutex); + xmms_usleep(10000); + g_static_mutex_lock(&buffer_mutex); + } + + /* calculate total time we spent in here */ + gettimeofday(&tv, NULL); + total = (tv.tv_sec - tv_start.tv_sec) * 1000 + + (tv.tv_usec - tv_start.tv_usec) / 1000; + + /* print some debug info */ + if(stopped) + DEBUG(("[crossfade] sync_output: ... stopped\n")) + else if(was_closed && opened) + DEBUG(("[crossfade] sync_output: ... reopened\n")) + else if(dt >= SYNC_OUTPUT_TIMEOUT) + DEBUG(("[crossfade] sync_output: ... TIMEOUT! (%ld ms)\n", total)) + else + DEBUG(("[crossfade] sync_output: ... done (%ld ms)\n", total)); +} + +void * +buffer_thread_f(void *arg) +{ + gpointer data; + gint sync; + gint op_free; + gint length_bak, length, blen; + glong timeout, dt; + gboolean stopping; + + struct timeval tv; + struct timeval mark; + + DEBUG(("[crossfade] buffer_thread_f: thread started (pid=%d)\n", + (int)getpid())); + + /* lock buffer */ + g_static_mutex_lock(&buffer_mutex); + + while(!stopped) { + /* yield */ +#ifdef DEBUG_HARDCORE + DEBUG(("[crossfade] buffer_thread_f: yielding...\n")); +#endif + g_static_mutex_unlock(&buffer_mutex); + xmms_usleep(10000); + g_static_mutex_lock(&buffer_mutex); + + /* --------------------------------------------------------------------- */ + + stopping = FALSE; + + /* V0.3.0: New timeout detection */ + if(!opened) { + gboolean current = bmp_playback_get_playing(); /* BEEP */ + + /* also see fini() */ + if(last_close.tv_sec || last_close.tv_usec) { + gettimeofday(&tv, NULL); + timeout = (tv.tv_sec - last_close.tv_sec) * 1000 + + (tv.tv_usec - last_close.tv_usec) / 1000; + } + else + timeout = -1; + + if(current != input_playing) { + input_playing = current; + if(current) + DEBUG(("[crossfade] buffer_thread_f:" + " input restarted after %ld ms\n", timeout)) + else + DEBUG(("[crossfade] buffer_thread_f:" + " input stopped after + %ld ms\n", timeout)); + } + + /* 0.3.0: HACK: output_keep_opened: play silence during prebuffering */ + if(input_playing && config->output_keep_opened && (buffer->used == 0)) { + buffer->silence = 0; + buffer->silence_len = MS2B(100); + } + + /* FIXME: make timeout configureable */ + if(((timeout < 0) || (timeout >= 100)) && !input_playing) { + if(playing) + DEBUG(("[crossfade] buffer_thread_f: timeout:" + " input did not restart after %ld ms (playing=%d)\n", timeout, playing)); + stopping = TRUE; + } + } + + /* V0.2.4: Moved the timeout checks in front of the buffer_free() check + * below. Before, buffer_thread_f could (theoretically) loop + * endlessly if buffer_free() returned 0 all the time. */ + + /* calculate time since last write to the buffer (ignore overflows) */ + gettimeofday(&tv, NULL); + timeout = (tv.tv_sec - last_write.tv_sec) * 1000 + + (tv.tv_usec - last_write.tv_usec) / 1000; + + /* check for timeout/eop (note this is the only way out of this loop) */ + if(stopping) { + if(playing) { + DEBUG(("[crossfade] buffer_thread_f: timeout: manual stop\n")); + + /* if CONFIG_STOP is of TYPE_NONE, immediatelly close the device... */ + if((config->fc[FADE_CONFIG_STOP].type == FADE_TYPE_NONE) + && !config->output_keep_opened) break; + + /* special handling for pause */ + if(paused) { + DEBUG(("[crossfade] buffer_thread_f: timeout: paused, closing now...\n")); + paused = FALSE; + if(config->output_keep_opened) + the_op->pause(0); + else + break; + } + else if(buffer->pause >= 0) { + DEBUG(("[crossfade] buffer_thread_f: timeout: cancelling pause countdown\n")); + buffer->pause = -1; + } + + /* ...otherwise, do the fadeout first */ + xfade_apply_fade_config(&config->fc[FADE_CONFIG_STOP]); + + /* force CONFIG_START in case the user restarts playback during fadeout */ + fade_config = &config->fc[FADE_CONFIG_START]; + playing = FALSE; + eop = TRUE; + } + else { + if(!eop) { + DEBUG(("[crossfade] buffer_thread_f: timeout: end of playback\n")); + + /* 0.3.3: undo trailing gap killer at end of playlist */ + if(buffer->gap_killed) { + buffer->used += buffer->gap_killed; + DEBUG(("[crossfade] buffer_thread_f: timeout:" + " undoing trailing gap (%d ms)\n", B2MS(buffer->gap_killed))); + } + + /* do the fadeout if applicable */ + if(config->fc[FADE_CONFIG_EOP].type != FADE_TYPE_NONE) + xfade_apply_fade_config(&config->fc[FADE_CONFIG_EOP]); + + fade_config = &config->fc[FADE_CONFIG_START]; /* see above */ + eop = TRUE; + } + + if(buffer->used == 0) { + if(config->output_keep_opened) { + /* 0.3.0: play silence while keeping the output opened */ + buffer->silence = 0; + buffer->silence_len = MS2B(100); + } + else if(buffer->silence_len <= 0) { + sync_output(); + if(opened) { + DEBUG(("[crossfade] buffer_thread_f: timeout, eop: device has been reopened\n")); + DEBUG(("[crossfade] buffer_thread_f: timeout, eop: -> continuing playback\n")); + eop = FALSE; + } + else { + DEBUG(("[crossfade] buffer_thread_f: timeout, eop: closing output...\n")); + break; + } + } + } + } + } + else + eop = FALSE; + + /* --------------------------------------------------------------------- */ + + /* get free space in device output buffer + * NOTE: disk_writer always returns here */ + op_free = the_op->buffer_free() & -4; + + /* continue waiting if there is no room in the device buffer */ + if(op_free == 0) continue; + + /* --- Limit OP buffer use (decreases latency) ------------------------- */ + + /* HACK: limit output plugin buffer usage to decrease latency */ + if(config->enable_op_max_used) { + gint output_time = the_op->output_time(); + gint output_used = the_op->written_time() - output_time; + gint output_limit = MS2B(config->op_max_used_ms - MIN(output_used, config->op_max_used_ms)); + + if(output_flush_time != output_time) { +#ifdef SONGCHANGE_TIMEOUT + if(timeout < config->songchange_timeout) { + /* slow down output, but always write _some_ data */ + if(output_limit < in_format.bps/100/2) + output_limit = in_format.bps/100/2; + + if(op_free > output_limit) + op_free = output_limit; + } + else { + if((output_used < config->op_max_used_ms) && (op_free > output_limit)) + op_free = output_limit; + else + op_free = MIN(op_free, 2304); /* avoid 0 */ + } +#else + /* slow down output, but always write _some_ data */ + if(output_limit < in_format.bps/100/2) + output_limit = in_format.bps/100/2; + + if(op_free > output_limit) + op_free = output_limit; +#endif + } + } + + /* --- write silence --------------------------------------------------- */ + + if(!paused && (buffer->silence <= 0) && (buffer->silence_len >= 4)) { + /* write as much silence as a) there is left and b) the device can take */ + length = buffer->silence_len; + if(length > op_free) length = op_free; + + /* make sure we always operate on stereo sample boundary */ + length &= -4; + + /* HACK: don't stay in here too long when in realtime mode (see below) */ + if(realtime) gettimeofday(&mark, NULL); + + /* write length bytes to the device */ + length_bak = length; + while(length > 0) { + data = zero_4k; + blen = sizeof(zero_4k); + if(blen > length) blen = length; + + /* make sure zero_4k is cleared. The effect plugin within + * the output plugin may have modified this buffer! (0.2.8) */ + memset(zero_4k, 0, blen); + + /* HACK: the original OSS plugin hangs when writing large + * blocks (greater than device buffer size) in realtime mode */ + if(the_op_config.max_write_enable && (blen > the_op_config.max_write_len)) + blen = the_op_config.max_write_len; + + /* finally, write data */ + the_op->write_audio(data, blen); + length -= blen; + + /* HACK: don't stay in here too long (force yielding every 10 ms) */ + if(realtime) { + gettimeofday(&tv, NULL); + dt = (tv.tv_sec - mark.tv_sec) * 1000 + + (tv.tv_usec - mark.tv_usec) / 1000; + if(dt >= 10) break; + } + } + + /* calculate how many bytes actually have been written */ + length = length_bak - length; + } + + else /* --- write data ------------------------------------------------- */ + + if(!paused && (buffer->preload <= 0) && (buffer->used >= 4)) { + /* write as much data as a) is available and b) the device can take */ + length = buffer->used; + if(length > op_free) length = op_free; + + /* HACK: throttle output (used with fast output plugins) */ + if(the_op_config.throttle_enable && !realtime && opened +#ifdef SONGCHANGE_TIMEOUT + && (timeout < config->songchange_timeout) +#endif + ) { + sync = buffer->sync_size - (buffer->size - buffer->used); + if(sync < 0) + length = 0; + else if(sync < length) + length = sync; + } + + /* clip length to silence countdown (if applicable) */ + if((buffer->silence >= 4) && (length > buffer->silence)) + length = buffer->silence; + + /* clip length to reopen countdown (if applicable) */ + if((buffer->reopen >= 0) && (length > buffer->reopen)) + length = buffer->reopen; + + /* clip length to pause countdown (if applicable) */ + if((buffer->pause >= 0) && (length > buffer->pause)) + length = buffer->pause; + + /* make sure we always operate on stereo sample boundary */ + length &= -4; + + /* HACK: don't stay in here too long when in realtime mode (see below) */ + if(realtime) gettimeofday(&mark, NULL); + + /* write length bytes to the device */ + length_bak = length; + while(length > 0) { + data = (gpointer)((gchar *)(buffer->data) + buffer->rd_index); //yaz + blen = buffer->size - buffer->rd_index; + if(blen > length) blen = length; + + /* HACK: the original OSS plugin hangs when writing large + * blocks (greater than device buffer size) in realtime mode */ + if(the_op_config.max_write_enable + && (blen > the_op_config.max_write_len)) + blen = the_op_config.max_write_len; + + /* finally, write data */ + the_op->write_audio(data, blen); + + buffer->rd_index = (buffer->rd_index + blen) % buffer->size; + buffer->used -= blen; + length -= blen; + + /* HACK: don't stay in here too long (force yielding every 10 ms) */ + if(realtime) { + gettimeofday(&tv, NULL); + dt = (tv.tv_sec - mark.tv_sec) * 1000 + + (tv.tv_usec - mark.tv_usec) / 1000; + if(dt >= 10) break; + } + } + + /* calculate how many bytes actually have been written */ + length = length_bak - length; + } + else + length = 0; + + /* update realtime throttling */ + output_written += length; + output_streampos += length; + + /* --- check countdowns ------------------------------------------------ */ + + if(buffer->silence > 0) { + buffer->silence -= length; + if(buffer->silence < 0) + DEBUG(("[crossfade] buffer_thread_f: WARNING: silence overrun: %d\n", + buffer->silence)); + } + else if(buffer->silence_len > 0) { + buffer->silence_len -= length; + if(buffer->silence_len <= 0) { + if(buffer->silence_len < 0) + DEBUG(("[crossfade] buffer_thread_f: WARNING: silence_len overrun: %d\n", + buffer->silence_len)); + } + } + + if((buffer->reopen >= 0) && !((buffer->silence <= 0) && (buffer->silence_len > 0))) { + buffer->reopen -= length; + if(buffer->reopen <= 0) { + if(buffer->reopen < 0) + DEBUG(("[crossfade] buffer_thread_f: WARNING: reopen overrun: %d\n", + buffer->reopen)); + + DEBUG(("[crossfade] buffer_thread_f: closing/reopening device\n")); + if(buffer->reopen_sync) sync_output(); + + if(the_op->close_audio) the_op->close_audio(); + if(!the_op->open_audio(out_format.fmt, out_format.rate, out_format.nch)) { + DEBUG(("[crossfade] buffer_thread_f: reopening output plugin failed!\n")); + g_free(buffer->data); + output_opened = FALSE; + g_static_mutex_unlock(&buffer_mutex); + g_thread_exit(0); + } + + output_flush_time = 0; + output_written = 0; + output_streampos = 0; + + /* We need to take the leading gap killer into account here: + * It will fix streampos only after gapkilling has finished. + * So, if gapkilling is still in progress at this point, we + * have to fix it ourselves. */ + output_offset = buffer->used; + if((buffer->gap_len > 0) && (buffer->gap > 0)) + output_offset += buffer->gap_len - buffer->gap; + output_offset = B2MS(output_offset) - xfade_written_time(); + + /* make sure reopen is not 0 */ + buffer->reopen = -1; + } + } + + if(buffer->pause >= 0) { + buffer->pause -= length; + if(buffer->pause <= 0) { + if(buffer->pause < 0) + DEBUG(("[crossfade] buffer_thread_f: WARNING: pause overrun: %d\n", + buffer->pause)); + + DEBUG(("[crossfade] buffer_thread_f: pausing output\n")); + + paused = TRUE; + sync_output(); + + if(!paused) + DEBUG(("[crossfade] buffer_thread_f: unpause during sync\n")) + else + the_op->pause(1); + + buffer->pause = -1; + } + } + } + + /* ----------------------------------------------------------------------- */ + + /* cleanup: close output */ + if(output_opened) { + xfade_stop_monitor(); + + if(!finishing) { + if(the_op->close_audio) the_op->close_audio(); + g_free(buffer->data); + output_opened = FALSE; + } + } + else + DEBUG(("[crossfade] buffer_thread_f: output already closed!\n")); + + /* acknowledge 'finishing' (see fini()) */ + finishing = FALSE; + + /* ----------------------------------------------------------------------- */ + + /* unlock buffer */ + g_static_mutex_unlock(&buffer_mutex); + + /* done */ + DEBUG(("[crossfade] buffer_thread_f: thread finished\n")); + g_thread_exit(0); + + return NULL; /* avoid compiler warning */ +} + +void +xfade_close_audio() +{ + DEBUG(("[crossfade] close:\n")); + + /* lock buffer */ + g_static_mutex_lock(&buffer_mutex); + + /* sanity... the vorbis plugin likes to call close_audio() twice */ + if(!opened) { + DEBUG(("[crossfade] close: WARNING: not opened!\n")); + g_static_mutex_unlock(&buffer_mutex); + return; + } + + /* HACK: FIXME: */ + if(input_stopped_for_restart && input_stopped_for_restart()) + DEBUG(("[crossfade] close: playback will restart soon\n")); + + if(playing) { + /* immediatelly close output when paused */ + if(paused) { + buffer->pause = -1; + paused = FALSE; + if(config->output_keep_opened) { + buffer->used = 0; + the_op->flush(0); + the_op->pause(0); + } + else + stopped = TRUE; + } + + /* HACK: If playlist_get_info_going is not true here, + * XMMS is about to exit. In this case, we stop + * the buffer thread before returning from this + * function. Otherwise, SEGFAULT may occur when + * XMMS tries to cleanup an output plugin which + * we are still using. + * + * NOTE: This hack has become obsolete as of 0.3.5. + * See output_list_hack(). + */ +#if 0 + if((xmms_playlist_get_info_going && !*xmms_playlist_get_info_going) || + (xmms_is_quitting && *xmms_is_quitting)) { + DEBUG(("[crossfade] close: stop (about to quit)\n")) + +#if 1 + /* wait for buffer thread to clean up and terminate */ + stopped = TRUE; + while(output_opened) { + g_static_mutex_unlock(&buffer_mutex); + xmms_usleep(10000); + g_static_mutex_lock(&buffer_mutex); + } +#endif + } + else +#endif + DEBUG(("[crossfade] close: stop\n")); + + fade_config = &config->fc[FADE_CONFIG_MANUAL]; + } + else { + DEBUG(("[crossfade] close: songchange/eop\n")); + + /* kill trailing gap (does not use buffer->gap_*) */ + if(output_opened && xfade_cfg_gap_trail_enable(config)) { + gint gap_len = MS2B(xfade_cfg_gap_trail_len(config)) & -4; + gint gap_level = xfade_cfg_gap_trail_level(config); + gint length = MIN(gap_len, buffer->used); + + DEBUG(("[crossfade] close: len=%d level=%d length=%d\n", gap_len, gap_level, length)); + + buffer->gap_killed = 0; + while(length > 0) { + gint wr_xedni = (buffer->rd_index + buffer->used-1) % buffer->size + 1; + gint blen = MIN(length, wr_xedni); + gint16 *p = (gint16 *)((gchar *)(buffer->data) + wr_xedni); //yaz + gint index = 0; + + while(index < blen) { + gint16 right = *--p, left = *--p; + if(ABS(left) >= gap_level) break; + if(ABS(right) >= gap_level) break; + index += 4; + } + + buffer->used -= index; + buffer->gap_killed += index; + + if(index < blen) break; + length -= blen; + } + + DEBUG(("[crossfade] close: trailing gap size: %d/%d ms\n", + B2MS(buffer->gap_killed), B2MS(gap_len))); + } + + /* skip to previous zero crossing */ + if(output_opened && config->gap_crossing) { + int crossing; + + buffer->gap_skipped = 0; + for(crossing = 0; crossing<4; crossing++) { + while(buffer->used > 0) { + gint wr_xedni = (buffer->rd_index + buffer->used-1) % buffer->size + 1; + gint blen = MIN(buffer->used, wr_xedni); + gint16 *p = (gint16 *)((gchar *)(buffer->data) + wr_xedni); //yaz + gint index = 0; + + while(index < blen) { + gint16 left = (--p, *--p); + if((crossing & 1) ^ (left > 0)) break; + index += 4; + } + + buffer->used -= index; + buffer->gap_skipped += index; + + if(index < blen) break; + } + } + DEBUG(("[crossfade] close: skipped %d bytes to previous zero crossing\n", buffer->gap_skipped)); + + /* update gap_killed (for undoing gap_killer in case of EOP) */ + buffer->gap_killed += buffer->gap_skipped; + } + + fade_config = &config->fc[FADE_CONFIG_XFADE]; + } + + /* XMMS has left the building */ + opened = FALSE; + + /* update last_close */ + gettimeofday(&last_close, NULL); + input_playing = FALSE; + + /* unlock buffer */ + g_static_mutex_unlock(&buffer_mutex); +} + +void +xfade_flush(gint time) +{ + DEBUG(("[crossfade] flush: time=%d\n", time)); + + /* lock buffer */ + g_static_mutex_lock(&buffer_mutex); + + /* update streampos with new stream position (input format size) */ + streampos = ((gint64)time * in_format.bps / 1000) & -4; + + /* flush output device / apply seek crossfade */ + if(config->fc[FADE_CONFIG_SEEK].type == FADE_TYPE_FLUSH) { + /* flush output plugin */ + the_op->flush(time); + output_flush_time = time; + output_streampos = MS2B(time); + + /* flush buffer, disable leading gap killing */ + buffer_reset(buffer, config); + } + else if(paused) { + fade_config_t fc; + + /* clear buffer */ + buffer->used = 0; + + /* apply only the fade_in part of FADE_CONFIG_PAUSE */ + memcpy(&fc, &config->fc[FADE_CONFIG_PAUSE], sizeof(fc)); + fc.out_len_ms = 0; + fc.ofs_custom_ms = 0; + xfade_apply_fade_config(&fc); + } + else + xfade_apply_fade_config(&config->fc[FADE_CONFIG_SEEK]); + + /* restart realtime throttling (should find another name for that var) */ + output_written = 0; + + /* make sure that the gapkiller is disabled */ + buffer->gap = 0; + + /* update output offset */ + output_offset = the_op->written_time() - time + + B2MS(buffer->used) + B2MS(buffer->silence_len); + + /* unlock buffer */ + g_static_mutex_unlock(&buffer_mutex); + +#ifdef DEBUG_HARDCORE + DEBUG(("[crossfade] flush: time=%d: done.\n", time)); +#endif +} + +void +xfade_pause(short p) +{ + /* lock buffer */ + g_static_mutex_lock(&buffer_mutex); + + if(p) { + fade_config_t *fc = &config->fc[FADE_CONFIG_PAUSE]; + if(fc->type == FADE_TYPE_PAUSE_ADV) { + int fade, length, n; + int index = buffer->rd_index; + int out_len = MS2B(xfade_cfg_fadeout_len(fc)) & -4; + int in_len = MS2B(xfade_cfg_fadein_len(fc)) & -4; + int silence_len = MS2B(xfade_cfg_offset(fc)) & -4; + + /* limit fadeout/fadein len to available data in buffer */ + if((out_len + in_len) > buffer->used) { + out_len = (buffer->used / 2) & -4; + in_len = out_len; + } + + DEBUG(("[crossfade] pause: paused=1 out=%d in=%d silence=%d\n", + B2MS(out_len), B2MS(in_len), B2MS(silence_len))); + + /* fade out (modifies buffer directly) */ + fade = 0; + length = out_len; + while(length > 0) { + gint16 *p = (gint16 *)((gchar *)(buffer->data) + index); //yaz + gint blen = buffer->size - index; + if(blen > length) blen = length; + + for(n = blen/4; n > 0; n--) { + gfloat factor = 1.0f - ((gfloat)fade / out_len); + *p = (gfloat)*p * factor; p++; + *p = (gfloat)*p * factor; p++; + fade += 4; + } + + index = (index + blen) % buffer->size; + length -= blen; + } + + /* fade in (modifies buffer directly) */ + fade = 0; + length = in_len; + while(length > 0) { + gint16 *p = (gint16 *)((gchar *)(buffer->data) + index); //yaz + gint blen = buffer->size - index; + if(blen > length) blen = length; + + for(n = blen/4; n > 0; n--) { + gfloat factor = (gfloat)fade / in_len; + *p = (gfloat)*p * factor; p++; + *p = (gfloat)*p * factor; p++; + fade += 4; + } + + index = (index + blen) % buffer->size; + length -= blen; + } + + /* start silence and pause countdowns */ + buffer->silence = out_len; + buffer->silence_len = silence_len; + buffer->pause = out_len + silence_len; + paused = FALSE; /* (!) will be set to TRUE in buffer_thread_f */ + } + else { + the_op->pause(1); + paused = TRUE; + DEBUG(("[crossfade] pause: paused=1\n")); + } + } + else { + the_op->pause(0); + buffer->pause = -1; + paused = FALSE; + DEBUG(("[crossfade] pause: paused=0\n")); + } + + /* unlock buffer */ + g_static_mutex_unlock(&buffer_mutex); +} + +gint +xfade_buffer_free() +{ + gint size, free; + +#ifdef DEBUG_HARDCORE + DEBUG(("[crossfade] buffer_free:\n")); +#endif + + /* sanity check */ + if(!output_opened) { + DEBUG(("[crossfade] buffer_free: WARNING: output closed!\n")); + return buffer->sync_size; + } + + /* lock buffer */ + g_static_mutex_lock(&buffer_mutex); + + size = buffer->size; + + /* When running in realtime mode, we need to take special care here: + * While XMMS is writing data to the output plugin, it will not yield + * ANY processing time to the buffer thread. It will only stop when + * xfade_buffer_free() no longer reports free buffer space. */ + if(realtime) { + gint64 wanted = output_written + buffer->preload_size; + + /* Fix for XMMS misbehaviour (possibly a bug): If the free space as + * returned by xfade_buffer_free() is below a certain minimum block size + * (tests showed 2304 bytes), XMMS will not send more data until there + * is enough room for one of those blocks. + * + * This breaks preloading in realtime mode. To make sure that the pre- + * load buffer gets filled we request additional sync_size bytes. */ + wanted += buffer->sync_size; + + if(wanted <= size) size = wanted; + } + + free = size - buffer->used; + if(free < 0) free = 0; + + /* unlock buffer */ + g_static_mutex_unlock(&buffer_mutex); + + /* Convert to input format size. For input rates > output rate this will + * return less free space than actually is available, but we don't care. */ + free /= (out_format.rate / (in_format.rate+1)) + 1; + if(in_format.is_8bit) free /= 2; + if(in_format.nch == 1) free /= 2; + +#ifdef DEBUG_HARDCORE + DEBUG(("[crossfade] buffer_free: %d\n", free)); +#endif + return free; +} + +gint +xfade_buffer_playing() +{ + /* always return FALSE here (if not in pause) so XMMS immediatelly + * starts playback of the next song */ + + /* + * NOTE: this causes trouble when playing HTTP audio streams. + * + * mpg123.lib will start prebuffering (and thus stalling output) when both + * 1) it's internal buffer is emptied (does happen all the time) + * 2) the output plugin's buffer_playing() (this function) returns FALSE + */ + + if(paused) + playing = TRUE; + else + playing = (is_http && (buffer->used > 0) && the_op->buffer_playing()) + || ((buffer->reopen >= 0) || (buffer->silence > 0) || (buffer->silence_len > 0)); + +#ifdef DEBUG_HARDCORE + DEBUG(("[crossfade] buffer_playing: %d\n", playing)); +#endif + return playing; +} + +gint +xfade_written_time() +{ + if(!output_opened) return 0; + return (gint)(streampos * 1000 / in_format.bps); +} + +gint +xfade_output_time() +{ + gint time; + +#ifdef DEBUG_HARDCORE + DEBUG(("[crossfade] output_time:\n")); +#endif + + /* sanity check (note: this one _does_ happen all the time) */ + if(!output_opened) return 0; + + /* lock buffer */ + g_static_mutex_lock(&buffer_mutex); + + time = the_op->output_time() - output_offset; + if(time < 0) time = 0; + + /* unlock buffer */ + g_static_mutex_unlock(&buffer_mutex); + +#ifdef DEBUG_HARDCORE + DEBUG(("[crossfade] output_time: time=%d\n", time)); +#endif + return time; +} diff -ruN audacious-1.0.0.org/Plugins/Output/crossfade/crossfade.h audacious-1.0.0/Plugins/Output/crossfade/crossfade.h --- audacious-1.0.0.org/Plugins/Output/crossfade/crossfade.h 1970-01-01 09:00:00.000000000 +0900 +++ audacious-1.0.0/Plugins/Output/crossfade/crossfade.h 2006-04-17 19:48:34.000000000 +0900 @@ -0,0 +1,507 @@ +/* + * XMMS Crossfade Plugin + * Copyright (C) 2000-2004 Peter Eisenlohr + * + * based on the original OSS Output Plugin + * Copyright (C) 1998-2000 Peter Alm, Mikael Alm, Olle Hallnas, Thomas Nilsson and 4Front Technologies + * + * 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, + * USA. + */ + +#ifndef _CROSSFADE_H_ +#define _CROSSFADE_H_ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include +#include + +#include "audacious/plugin.h" +#include "libaudacious/beepctrl.h" +#include "libaudacious/configdb.h" +#include "libaudacious/util.h" + +#include "debug.h" + +#undef VOLUME_NORMALIZER +#undef SONGCHANGE_TIMEOUT + +#define OUTPUT_RATE the_rate +#define OUTPUT_NCH 2 +#define OUTPUT_BPS (OUTPUT_RATE * OUTPUT_NCH * 2) + +#define SYNC_OUTPUT_TIMEOUT 2000 + +#define OUTPUT_METHOD_PLUGIN 0 +#define OUTPUT_METHOD_BUILTIN_NULL 1 + +#define FADE_CONFIG_XFADE 0 +#define FADE_CONFIG_MANUAL 1 +#define FADE_CONFIG_ALBUM 2 +#define FADE_CONFIG_START 3 +#define FADE_CONFIG_STOP 4 +#define FADE_CONFIG_EOP 5 +#define FADE_CONFIG_SEEK 6 +#define FADE_CONFIG_PAUSE 7 +#define FADE_CONFIG_TIMING 8 +#define MAX_FADE_CONFIGS 9 + +#define FADE_TYPE_REOPEN 0 +#define FADE_TYPE_FLUSH 1 +#define FADE_TYPE_NONE 2 +#define FADE_TYPE_PAUSE 3 +#define FADE_TYPE_SIMPLE_XF 4 +#define FADE_TYPE_ADVANCED_XF 5 +#define FADE_TYPE_FADEIN 6 +#define FADE_TYPE_FADEOUT 7 +#define FADE_TYPE_PAUSE_NONE 8 +#define FADE_TYPE_PAUSE_ADV 9 +#define MAX_FADE_TYPES 10 + +#define TYPEMASK_XFADE ((1 << FADE_TYPE_REOPEN) | \ + (1 << FADE_TYPE_NONE) | \ + (1 << FADE_TYPE_PAUSE) | \ + (1 << FADE_TYPE_SIMPLE_XF) | \ + (1 << FADE_TYPE_ADVANCED_XF)) + +#define TYPEMASK_MANUAL ((1 << FADE_TYPE_REOPEN) | \ + (1 << FADE_TYPE_FLUSH) | \ + (1 << FADE_TYPE_NONE) | \ + (1 << FADE_TYPE_PAUSE) | \ + (1 << FADE_TYPE_SIMPLE_XF) | \ + (1 << FADE_TYPE_ADVANCED_XF)) + +#define TYPEMASK_ALBUM ((1 << FADE_TYPE_NONE)) + +#define TYPEMASK_START ((1 << FADE_TYPE_NONE) | \ + (1 << FADE_TYPE_FADEIN)) + +#define TYPEMASK_STOP ((1 << FADE_TYPE_NONE) | \ + (1 << FADE_TYPE_FADEOUT)) + +#define TYPEMASK_EOP ((1 << FADE_TYPE_NONE) | \ + (1 << FADE_TYPE_FADEOUT)) + +#define TYPEMASK_SEEK ((1 << FADE_TYPE_FLUSH) | \ + (1 << FADE_TYPE_NONE) | \ + (1 << FADE_TYPE_SIMPLE_XF)) + +#define TYPEMASK_PAUSE ((1 << FADE_TYPE_PAUSE_NONE) | \ + (1 << FADE_TYPE_PAUSE_ADV)) + +#define TYPEMASK_TIMING (0) + +#define FC_OFFSET_NONE 0 +#define FC_OFFSET_LOCK_IN 1 +#define FC_OFFSET_LOCK_OUT 2 +#define FC_OFFSET_CUSTOM 3 + +#define DEFAULT_OP_CONFIG_STRING "libALSA.so=0,1,2304,0; libdisk_writer.so=1,0,2304,1" +#define DEFAULT_OP_NAME "libALSA.so" +#define DEFAULT_EP_NAME "libnormvol.so" + +#define DEFAULT_OP_CONFIG \ +{ FALSE, FALSE, 2304, FALSE } + +#define CONFIG_DEFAULT \ +{ 44100, /* output_rate */ \ + 2, /* output_quality */ \ + NULL, /* op_config_string */ \ + NULL, /* op_name */ \ + NULL, /* ep_name */ \ + FALSE, /* ep_enable */ \ + TRUE, /* volnorm_enable */ \ + 8000, /* volnorm_target */ \ + FALSE, /* volnorm_use_qa */ \ + 10000, /* mix_size_ms */ \ + TRUE, /* mix_size_auto */ \ + \ + { /* fc[MAX_FADE_CONFIGS] */ \ + { FADE_CONFIG_XFADE, /* config */ \ + FADE_TYPE_ADVANCED_XF, /* type */ \ + 2000, /* pause_len_ms */ \ + 6000, /* simple_len_ms */ \ + TRUE, 4000, 0, /* out_enable, _len_ms, _volume */ \ + FC_OFFSET_CUSTOM, /* ofs_type */ \ + FC_OFFSET_CUSTOM, -6000, /* ofs_type_wanted, ofs_custom_ms */ \ + TRUE, /* in_locked */ \ + FALSE, 4000, 33, /* in_enable, _len_ms, _volume */ \ + FALSE, /* - */ \ + 0, /* - */ \ + FALSE, /* - */ \ + 0, 0, /* - */ \ + FALSE, /* flush */ \ + TYPEMASK_XFADE /* type_mask */ \ + }, \ + { FADE_CONFIG_MANUAL, /* config */ \ + FADE_TYPE_SIMPLE_XF, /* type */ \ + 2000, /* pause_len_ms */ \ + 1000, /* simple_len_ms */ \ + TRUE, 500, 0, /* out_enable, _len_ms, _volume */ \ + FC_OFFSET_CUSTOM, /* ofs_type */ \ + FC_OFFSET_CUSTOM, -500, /* ofs_type_wanted, ofs_custom_ms */ \ + TRUE, /* in_locked */ \ + FALSE, 500, 50, /* in_enable, _len_ms, _volume */ \ + FALSE, /* flush_pause_enable */ \ + 500, /* flush_in_len_ms */ \ + FALSE, /* flush_in_enable */ \ + 500, 0, /* flush_in_len_ms, _volume */ \ + TRUE, /* flush */ \ + TYPEMASK_MANUAL /* type_mask */ \ + }, \ + { FADE_CONFIG_ALBUM, /* config */ \ + FADE_TYPE_NONE, /* type */ \ + 0, /* - */ \ + 0, /* - */ \ + FALSE, 0, 0, /* - */ \ + FC_OFFSET_NONE, /* - */ \ + FC_OFFSET_NONE, 0, /* - */ \ + FALSE, /* - */ \ + FALSE, 1000, 0, /* - */ \ + FALSE, /* - */ \ + 0, /* - */ \ + FALSE, /* - */ \ + 0, 0, /* - */ \ + FALSE, /* flush */ \ + TYPEMASK_ALBUM /* type_mask */ \ + }, \ + { FADE_CONFIG_START, /* config */ \ + FADE_TYPE_FADEIN, /* type */ \ + 0, /* - */ \ + 0, /* - */ \ + FALSE, 0, 0, /* - */ \ + FC_OFFSET_NONE, /* - */ \ + FC_OFFSET_NONE, 0, /* - */ \ + FALSE, /* - */ \ + FALSE, 100, 0, /* - in_len_ms, _volume */ \ + FALSE, /* - */ \ + 0, /* - */ \ + FALSE, /* - */ \ + 0, 0, /* - */ \ + TRUE, /* flush */ \ + TYPEMASK_START /* type_mask */ \ + }, \ + { FADE_CONFIG_STOP, /* config */ \ + FADE_TYPE_FADEOUT, /* type */ \ + 0, /* - */ \ + 0, /* - */ \ + FALSE, 100, 0, /* - out_len_ms, _volume */ \ + FC_OFFSET_NONE, /* - */ \ + FC_OFFSET_NONE, 500, /* - ofs_custom_ms */ \ + FALSE, /* - */ \ + FALSE, 0, 0, /* - */ \ + FALSE, /* - */ \ + 0, /* - */ \ + FALSE, /* - */ \ + 0, 0, /* - */ \ + TRUE, /* flush */ \ + TYPEMASK_STOP /* type_mask */ \ + }, \ + { FADE_CONFIG_EOP, /* config */ \ + FADE_TYPE_FADEOUT, /* type */ \ + 0, /* - */ \ + 0, /* - */ \ + FALSE, 100, 0, /* - out_len_ms, _volume */ \ + FC_OFFSET_NONE, /* - */ \ + FC_OFFSET_NONE, 500, /* - ofs_custom_ms */ \ + FALSE, /* - */ \ + FALSE, 0, 0, /* - */ \ + FALSE, /* - */ \ + 0, /* - */ \ + FALSE, /* - */ \ + 0, 0, /* - */ \ + FALSE, /* flush */ \ + TYPEMASK_EOP /* type_mask */ \ + }, \ + { FADE_CONFIG_SEEK, /* config */ \ + FADE_TYPE_SIMPLE_XF, /* type */ \ + 0, /* - */ \ + 50, /* simple_len_ms */ \ + FALSE, 0, 0, /* - */ \ + FC_OFFSET_NONE, /* - */ \ + FC_OFFSET_NONE, 0, /* - */ \ + FALSE, /* - */ \ + FALSE, 1000, 0, /* - */ \ + FALSE, /* - */ \ + 0, /* - */ \ + FALSE, /* - */ \ + 0, 0, /* - */ \ + TRUE, /* flush */ \ + TYPEMASK_SEEK /* type_mask */ \ + }, \ + { FADE_CONFIG_PAUSE, /* config */ \ + FADE_TYPE_PAUSE_ADV, /* type */ \ + 0, /* - */ \ + 0, /* - */ \ + TRUE, 100, 0, /* - out_len_ms, - */ \ + FC_OFFSET_NONE, /* - */ \ + FC_OFFSET_NONE, 100, /* - ofs_custom_ms */ \ + FALSE, /* - */ \ + TRUE, 100, 0, /* - in_len_ms, - */ \ + FALSE, /* - */ \ + 0, /* - */ \ + FALSE, /* - */ \ + 0, 0, /* - */ \ + FALSE, /* - */ \ + TYPEMASK_PAUSE /* type_mask */ \ + }, \ + { FADE_CONFIG_TIMING, /* config */ \ + FADE_TYPE_NONE, /* type */ \ + 0, /* - */ \ + 0, /* - */ \ + TRUE, 0, 0, /* out_enable, _len_ms, - */ \ + FC_OFFSET_CUSTOM, /* - */ \ + FC_OFFSET_CUSTOM, 0, /* - ofs_custom_ms */ \ + FALSE, /* - */ \ + TRUE, 0, 0, /* in_enable, _len_ms, - */ \ + FALSE, /* - */ \ + 0, /* - */ \ + FALSE, /* - */ \ + 0, 0, /* - */ \ + FALSE, /* flush */ \ + TYPEMASK_TIMING /* type_mask */ \ + } \ + }, \ + TRUE, /* gap_lead_enable */ \ + 500, /* gap_lead_len_ms */ \ + 512, /* gap_lead_level */ \ + TRUE, /* gap_trail_enable */ \ + 500, /* gap_trail_len_ms */ \ + 512, /* gap_trail_level */ \ + TRUE, /* gap_trail_locked */ \ + TRUE, /* gap_crossing */ \ + FALSE, /* enable_debug */ \ + FALSE, /* enable_monitor */ \ + TRUE, /* enable_mixer */ \ + FALSE, /* mixer_reverse */ \ + FALSE, /* mixer_software */ \ + 75, /* mixer_vol_left */ \ + 75, /* mixer_vol_right */ \ + 500, /* songchange_timeout */ \ + 0, /* preload_size_ms */ \ + TRUE, /* album detection */ \ + FALSE, /* no_xfade_if_same_file */ \ + FALSE, /* enable_http_workaround */ \ + FALSE, /* enable_op_max_used */ \ + 250, /* op_max_used_ms */ \ + FALSE, /* output_keep_opened */ \ + NULL, /* presets */ \ + 250 /* sync_size_ms */ \ +} + + +#define DEBUG(x) {if(config->enable_debug) debug x;} +#define PERROR(x) {if(config->enable_debug) perror(x);} + +#define WRAP(x,n) (((x)<0)?((n)-(x))%(n):((x)%(n))) +#define B2MS(x) ((gint)((gint64)(x)*1000/OUTPUT_BPS)) +#define MS2B(x) ((gint)((gint64)(x)*OUTPUT_BPS/1000)) + + +/* get plugin info (imported by XMMS) */ +OutputPlugin *get_oplugin_info(); +OutputPlugin *get_crossfade_oplugin_info(); + +/* xmms internal prototypes */ /* XMMS */ +gint ctrlsocket_get_session_id(); +gboolean bmp_playback_get_playing(); +GList *get_output_list(); +GList *get_effect_list(); +gint get_playlist_position(); +gint playlist_get_current_length(); +#ifdef HAVE_PLAYLIST_GET_FILENAME +gchar *playlist_get_filename(gint pos); +#endif + +/* config change callbacks */ +void xfade_realize_config(); +void xfade_realize_ep_config(); + + +typedef struct +{ + gint mix_size; /* mixing buffer length */ + gint sync_size; /* additional buffer space for mix timing */ + gint preload_size; /* preload buffer length */ + + /* ---------------------------------------------------------------------- */ + + gpointer data; /* buffer */ + gint size; /* total buffer length */ + + /* ---------------------------------------------------------------------- */ + + gint used; /* length */ + gint rd_index; /* offset */ + + gint preload; /* > 0: preloading */ + + /* ---------------------------------------------------------------------- */ + + gint mix; /* > 0: mixing new data into buffer */ + + gint fade; /* > 0: fading in new data */ + gint fade_len; /* length of fadein */ + gfloat fade_scale; /* 1.0f - in_level */ + +#define GAP_SKIPPING_POSITIVE -1 +#define GAP_SKIPPING_NEGATIVE -2 +#define GAP_SKIPPING_DONE -3 + gint gap; /* > 0: removing (leading) gap */ + gint gap_len; /* max. len of gap, 0=disabled */ + gint gap_level; /* max. sample value+1 to be considered "silent" */ + gint gap_killed; /* number of bytes that were killed last time */ + gint gap_skipped; /* negative/positive samples skipped */ + + /* ---------------------------------------------------------------------- */ + + gint silence; /* > 0: delay until start of silence */ + gint silence_len; /* > 0: inserting silence */ + + gint reopen; /* >= 0: countdown to reopen device (disk_writer hack) */ + gboolean reopen_sync; /* TRUE: sync output plugin before reopening */ + + gint pause; /* >= 0: countdown to pause output plugin */ +} +buffer_t; + +typedef struct +{ + gint config; // one of FADE_CONFIG_*, constant + gint type; // one of FADE_TYPE_* + + gint pause_len_ms; // PAUSE + + gint simple_len_ms; // SIMPLE_XF + + gboolean out_enable; // ADVANCED_XF + gint out_len_ms; // ADVANCED_XF, FADEOUT, PAUSE + gint out_volume; // ADVANCED_XF, FADEOUT + + gint ofs_type; // ADVANCED_XF + gint ofs_type_wanted; // ADVANCED_XF + gint ofs_custom_ms; // ADVANCED_XF, FADEOUT (additional silence), PAUSE + + gboolean in_locked; // ADVANCED_XF + gboolean in_enable; // ADVANCED_XF, FLUSH + gint in_len_ms; // ADVANCED_XF, FLUSH, FADEIN, PAUSE + gint in_volume; // ADVANCED_XF, FLUSH, FADEIN + + gboolean flush_pause_enable; // FLUSH + gint flush_pause_len_ms; // FLUSH + gboolean flush_in_enable; // FLUSH + gint flush_in_len_ms; // FLUSH + gint flush_in_volume; // FLUSH + + /* additional stuff which is not configureable by the user */ + gboolean flush; // TRUE for manual, FALSE for xfade config + guint32 type_mask; // bitmask for FADE_TYPEs +} +fade_config_t; + +typedef struct +{ + gboolean throttle_enable; + gboolean max_write_enable; + gint max_write_len; + gboolean force_reopen; +} +plugin_config_t; + +typedef struct +{ + /* output: method */ + gint output_rate; + gint output_quality; + + /* output: plugin */ + gchar *op_config_string; /* stores configs for all plugins */ + gchar *op_name; /* name of the current plugin */ + + /* effects */ + gchar *ep_name; + gboolean ep_enable; + gboolean volnorm_enable; + gboolean volnorm_use_qa; + gint volnorm_target; + + /* crossfader */ + gint mix_size_ms; + gboolean mix_size_auto; + fade_config_t fc[MAX_FADE_CONFIGS]; + + /* gap killer */ + gboolean gap_lead_enable; + gint gap_lead_len_ms; + gint gap_lead_level; + + gboolean gap_trail_enable; + gint gap_trail_len_ms; + gint gap_trail_level; + gboolean gap_trail_locked; + + gboolean gap_crossing; + + /* misc */ + gboolean enable_debug; + gboolean enable_monitor; + + gboolean enable_mixer; + gboolean mixer_reverse; + gboolean mixer_software; + gint mixer_vol_left; + gint mixer_vol_right; + + gint songchange_timeout; + gint preload_size_ms; + gboolean album_detection; + gboolean no_xfade_if_same_file; + gboolean enable_http_workaround; + gboolean enable_op_max_used; + gint op_max_used_ms; + gboolean output_keep_opened; + + /* presets */ + GList *presets; + + /* additional stuff which is not configureable by the user */ + gint sync_size_ms; + + /* additional stuff which is not saved to the config file */ + gint page; + gint xf_index; +} +config_t; + + +/* some global vars... we should really get rid of those somehow */ +extern config_t *config; +extern config_t config_default; +extern buffer_t *buffer; + +extern GStaticMutex buffer_mutex; + +extern gboolean opened; /* XMMS-crossfade is opened */ +extern gboolean output_opened; /* the output plugin is opened */ +extern gint output_offset; +extern gint64 output_streampos; + +extern OutputPlugin *the_op; +extern gint the_rate; + +#endif /* _CROSSFADE_H_ */ diff -ruN audacious-1.0.0.org/Plugins/Output/crossfade/debug.c audacious-1.0.0/Plugins/Output/crossfade/debug.c --- audacious-1.0.0.org/Plugins/Output/crossfade/debug.c 1970-01-01 09:00:00.000000000 +0900 +++ audacious-1.0.0/Plugins/Output/crossfade/debug.c 2006-04-17 19:48:34.000000000 +0900 @@ -0,0 +1,34 @@ +/* + * XMMS Crossfade Plugin + * Copyright (C) 2000-2004 Peter Eisenlohr + * + * based on the original OSS Output Plugin + * Copyright (C) 1998-2000 Peter Alm, Mikael Alm, Olle Hallnas, Thomas Nilsson and 4Front Technologies + * + * 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, + * USA. + */ + +#include +#include + +void debug(char *format, ...) +{ + va_list ap; + + va_start(ap, format); + vfprintf(stderr, format, ap); + va_end (ap); +} diff -ruN audacious-1.0.0.org/Plugins/Output/crossfade/debug.h audacious-1.0.0/Plugins/Output/crossfade/debug.h --- audacious-1.0.0.org/Plugins/Output/crossfade/debug.h 1970-01-01 09:00:00.000000000 +0900 +++ audacious-1.0.0/Plugins/Output/crossfade/debug.h 2006-04-17 19:48:34.000000000 +0900 @@ -0,0 +1,34 @@ +/* + * XMMS Crossfade Plugin + * Copyright (C) 2000-2004 Peter Eisenlohr + * + * based on the original OSS Output Plugin + * Copyright (C) 1998-2000 Peter Alm, Mikael Alm, Olle Hallnas, Thomas Nilsson and 4Front Technologies + * + * 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, + * USA. + */ + +#ifndef __DEBUG_H__ +#define __DEBUG_H__ + +#ifdef __GNUC__ +/* enable -Wformat with debug() */ +void debug(char *format, ...) __attribute__ ((format (printf, 1, 2))); +#else +void debug(char *format, ...); +#endif + +#endif /* __DEBUG_H__ */ diff -ruN audacious-1.0.0.org/Plugins/Output/crossfade/effect.c audacious-1.0.0/Plugins/Output/crossfade/effect.c --- audacious-1.0.0.org/Plugins/Output/crossfade/effect.c 1970-01-01 09:00:00.000000000 +0900 +++ audacious-1.0.0/Plugins/Output/crossfade/effect.c 2006-04-17 19:48:34.000000000 +0900 @@ -0,0 +1,161 @@ +/* + * XMMS Crossfade Plugin + * Copyright (C) 2000-2004 Peter Eisenlohr + * + * based on the original OSS Output Plugin + * Copyright (C) 1998-2000 Peter Alm, Mikael Alm, Olle Hallnas, Thomas Nilsson and 4Front Technologies + * + * 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, + * USA. + */ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include +#include "effect.h" + +void +effect_init(effect_context_t *ec, + EffectPlugin *ep) +{ + memset(ec, 0, sizeof(*ec)); + effect_set_plugin(ec, ep); +} + +static char * +plugin_name(EffectPlugin *ep) +{ + return ep->description ? ep->description : ""; +} + + +void +effect_set_plugin(effect_context_t *ec, + EffectPlugin *ep) +{ + if(ec->use_xmms_plugin && (ep == EFFECT_USE_XMMS_PLUGIN)) return; + if(ec->ep == ep) return; + + if(ec->last_ep) { + if(ec->last_ep->cleanup) { + DEBUG(("[crossfade] effect: \"%s\" deselected, cleanup\n", plugin_name(ec->last_ep))); + ec->last_ep->cleanup(); + } + else + DEBUG(("[crossfade] effect: \"%s\" deselected\n", plugin_name(ec->last_ep))); + } + + ec->use_xmms_plugin = (ep == EFFECT_USE_XMMS_PLUGIN); + ec->ep = ec->use_xmms_plugin ? NULL : ep; + ec->last_ep = ec->ep; + ec->is_active = FALSE; + + if(ec->ep) { + if(ec->ep->init) { + DEBUG(("[crossfade] effect: \"%s\" selected, init\n", plugin_name(ec->ep))); + ec->ep->init(); + } + else + DEBUG(("[crossfade] effect: \"%s\" selected\n", plugin_name(ec->ep))); + } +} + +gint +effect_flow(effect_context_t *ec, + gpointer *buffer, + gint length, + format_t *format, + gboolean allow_format_change) +{ + EffectPlugin *ep; + + if(ec->use_xmms_plugin ? effects_enabled() : (ec->ep != NULL)) { + ep = ec->use_xmms_plugin ? get_current_effect_plugin() : ec->ep; + + if(ep != ec->last_ep) { + DEBUG(("[crossfade] effect: plugin: \"%s\"%s\n", + ep ? plugin_name(ep) : "", + ec->use_xmms_plugin ? " (XMMS)" : "")); + ec->last_ep = ep; + ec->is_active = FALSE; + } + if(ep == NULL) return length; + + if(ep->query_format) { + AFormat fmt = format->fmt; + gint rate = format->rate; + gint nch = format->nch; + + ep->query_format(&fmt, &rate, &nch); + if(!ec->is_active + || (ec->fmt != fmt) + || (ec->rate != rate) + || (ec->nch != nch)) { + if(!allow_format_change && (!format_match(fmt, format->fmt) || + (rate != format->rate) || + (nch != format->nch))) { + DEBUG(("[crossfade] effect: format mismatch: " + "in=(%s/%d/%d) out=(%s/%d/%d)\n", + format_name(format->fmt), format->rate, format->nch, + format_name(fmt), rate, nch)); + ec->is_valid = FALSE; + } + else { + if(setup_format(fmt, rate, nch, &ec->format) < 0) { + DEBUG(("[crossfade] effect: format not supported " + "(fmt=%s rate=%d nch=%d)!\n", + format_name(fmt), rate, nch)); + ec->is_valid = FALSE; + } + else { + ec->is_valid = TRUE; + DEBUG(("[crossfade] effect: plugin enabled " + "(fmt=%s rate=%d nch=%d)\n", format_name(fmt), rate, nch)); + } + } + + ec->is_active = TRUE; + ec->fmt = fmt; + ec->rate = rate; + ec->nch = nch; + } + if(ec->is_valid && ep->mod_samples) { + length = ep->mod_samples(buffer, length, format->fmt, format->rate, format->nch); + if(allow_format_change) format_copy(format, &ec->format); + } + } + else { + ec->is_active = TRUE; + if(ep->mod_samples) + length = ep->mod_samples(buffer, length, format->fmt, format->rate, format->nch); + } + } + else if(ec->is_active) { + ec->is_active = FALSE; + DEBUG(("[crossfade] effect: plugin disabled\n")); + } + + return length; +} + +void +effect_free(effect_context_t *ec) +{ + /* nothing to do */ +} + + diff -ruN audacious-1.0.0.org/Plugins/Output/crossfade/effect.h audacious-1.0.0/Plugins/Output/crossfade/effect.h --- audacious-1.0.0.org/Plugins/Output/crossfade/effect.h 1970-01-01 09:00:00.000000000 +0900 +++ audacious-1.0.0/Plugins/Output/crossfade/effect.h 2006-04-17 19:48:34.000000000 +0900 @@ -0,0 +1,60 @@ +/* + * XMMS Crossfade Plugin + * Copyright (C) 2000-2004 Peter Eisenlohr + * + * based on the original OSS Output Plugin + * Copyright (C) 1998-2000 Peter Alm, Mikael Alm, Olle Hallnas, Thomas Nilsson and 4Front Technologies + * + * 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, + * USA. + */ + +#ifndef __EFFECT_H__ +#define __EFFECT_H__ + +#include "crossfade.h" +#include "format.h" + +#include + + +#define EFFECT_USE_XMMS_PLUGIN GINT_TO_POINTER(-1) + +typedef struct +{ + EffectPlugin *ep; + EffectPlugin *last_ep; + gboolean use_xmms_plugin; + gboolean is_active; + gboolean is_valid; + format_t format; + AFormat fmt; + gint rate; + gint nch; +} +effect_context_t; + +void effect_init (effect_context_t *ec, + EffectPlugin *ep); +void effect_set_plugin(effect_context_t *ec, + EffectPlugin *ep); +gint effect_flow (effect_context_t *ec, + gpointer *buffer, + gint length, + format_t *format, + gboolean allow_format_change); +void effect_free (effect_context_t *ec); + +#endif /* _EFFECT_H_ */ diff -ruN audacious-1.0.0.org/Plugins/Output/crossfade/format.c audacious-1.0.0/Plugins/Output/crossfade/format.c --- audacious-1.0.0.org/Plugins/Output/crossfade/format.c 1970-01-01 09:00:00.000000000 +0900 +++ audacious-1.0.0/Plugins/Output/crossfade/format.c 2006-04-17 19:48:34.000000000 +0900 @@ -0,0 +1,145 @@ +/* + * XMMS Crossfade Plugin + * Copyright (C) 2000-2004 Peter Eisenlohr + * + * based on the original OSS Output Plugin + * Copyright (C) 1998-2000 Peter Alm, Mikael Alm, Olle Hallnas, Thomas Nilsson and 4Front Technologies + * + * 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, + * USA. + */ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include +#include "format.h" + +gboolean +setup_format(AFormat fmt, gint rate, gint nch, format_t *format) +{ + format->bps = 0; + format->fmt = fmt; + format->is_8bit = FALSE; + format->is_swapped = FALSE; + format->is_unsigned = FALSE; + + /* check format */ + switch(fmt) { + case FMT_U8: + format->is_8bit = TRUE; + format->is_unsigned = TRUE; + break; + case FMT_S8: + format->is_8bit = TRUE; + break; + case FMT_U16_LE: + format->is_unsigned = TRUE; +#ifdef WORDS_BIGENDIAN + format->is_swapped = TRUE; +#endif + break; + case FMT_U16_BE: + format->is_unsigned = TRUE; +#ifndef WORDS_BIGENDIAN + format->is_swapped = TRUE; +#endif + break; + case FMT_U16_NE: + format->is_unsigned = TRUE; + break; + case FMT_S16_LE: +#ifdef WORDS_BIGENDIAN + format->is_swapped = TRUE; +#endif + break; + case FMT_S16_BE: +#ifndef WORDS_BIGENDIAN + format->is_swapped = TRUE; +#endif + break; + case FMT_S16_NE: + break; + default: + DEBUG(("[crossfade] setup_format: unknown format (%d)!\n", fmt)); + return -1; + } + + /* check rate */ + if((rate < 1) || (rate > 65535)) { + DEBUG(("[crossfade] setup_format: illegal rate (%d)!\n", rate)); + return -1; + } + format->rate = rate; + + /* check channels */ + switch(nch) { + case 1: + case 2: + format->nch = nch; + break; + default: + DEBUG(("[crossfade] setup_format: illegal # of channels (%d)!\n", nch)); + return -1; + } + + /* calculate bps */ + format->bps = rate * nch; + if(!format->is_8bit) format->bps *= 2; + + return 0; +} + +gboolean format_match(AFormat fmt1, AFormat fmt2) +{ + if(fmt1 == fmt2) return TRUE; /* exact match */ + + if((fmt2 == FMT_U16_NE) || (fmt2 == FMT_S16_NE)) { + AFormat fmt = fmt1; + fmt1 = fmt2; + fmt2 = fmt; + } + +#ifdef WORDS_BIGENDIAN + if(((fmt1 == FMT_U16_NE) && (fmt2 == FMT_U16_BE)) + || ((fmt1 == FMT_S16_NE) && (fmt2 == FMT_S16_BE))) return TRUE; +#else + if(((fmt1 == FMT_U16_NE) && (fmt2 == FMT_U16_LE)) + || ((fmt1 == FMT_S16_NE) && (fmt2 == FMT_S16_LE))) return TRUE; +#endif + + return FALSE; /* no match */ +} + +gchar *format_name(AFormat fmt) +{ + switch(fmt) { + case FMT_U8: return "FMT_U8"; + case FMT_S8: return "FMT_S8"; + case FMT_U16_LE: return "FMT_U16_LE"; + case FMT_U16_BE: return "FMT_U16_BE"; + case FMT_U16_NE: return "FMT_U16_NE"; + case FMT_S16_LE: return "FMT_S16_LE"; + case FMT_S16_BE: return "FMT_S16_BE"; + case FMT_S16_NE: return "FMT_S16_NE"; + } + return "UNKNOWN"; +} + +void format_copy(format_t *dest, format_t *src) +{ + memcpy(dest, src, sizeof(format_t)); +} diff -ruN audacious-1.0.0.org/Plugins/Output/crossfade/format.h audacious-1.0.0/Plugins/Output/crossfade/format.h --- audacious-1.0.0.org/Plugins/Output/crossfade/format.h 1970-01-01 09:00:00.000000000 +0900 +++ audacious-1.0.0/Plugins/Output/crossfade/format.h 2006-04-17 19:48:34.000000000 +0900 @@ -0,0 +1,56 @@ +/* + * XMMS Crossfade Plugin + * Copyright (C) 2000-2004 Peter Eisenlohr + * + * based on the original OSS Output Plugin + * Copyright (C) 1998-2000 Peter Alm, Mikael Alm, Olle Hallnas, Thomas Nilsson and 4Front Technologies + * + * 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, + * USA. + */ + +/* + * Verify format and setup a struct format_t + * Returns -1 if an illegal format has been specified + */ + +#ifndef __FORMAT_H__ +#define __FORMAT_H__ + +#include "crossfade.h" + +typedef struct { + AFormat fmt; + gint rate; + gint nch; + + gint bps; /* format is valid if (bps > 0) */ + gboolean is_8bit; + gboolean is_swapped; + gboolean is_unsigned; +} +format_t; + +gboolean setup_format(AFormat fmt, + gint rate, + gint nch, + format_t *format); + +gboolean format_match(AFormat fmt1, AFormat fmt2); +gchar * format_name (AFormat fmt); + +void format_copy(format_t *dest, format_t *src); + +#endif /* _FORMAT_H_ */ diff -ruN audacious-1.0.0.org/Plugins/Output/crossfade/interface-2.0.c audacious-1.0.0/Plugins/Output/crossfade/interface-2.0.c --- audacious-1.0.0.org/Plugins/Output/crossfade/interface-2.0.c 1970-01-01 09:00:00.000000000 +0900 +++ audacious-1.0.0/Plugins/Output/crossfade/interface-2.0.c 2006-04-17 19:48:34.000000000 +0900 @@ -0,0 +1,2492 @@ +/* + * DO NOT EDIT THIS FILE - it is generated by Glade. + */ + +#ifdef HAVE_CONFIG_H +# include +#endif + +#include +#include +#include +#include +#include + +#include +#include + +#include "callbacks.h" +#include "interface-2.0.h" +#include "support-2.0.h" + +#define GLADE_HOOKUP_OBJECT(component,widget,name) \ + g_object_set_data_full (G_OBJECT (component), name, \ + gtk_widget_ref (widget), (GDestroyNotify) gtk_widget_unref) + +#define GLADE_HOOKUP_OBJECT_NO_REF(component,widget,name) \ + g_object_set_data (G_OBJECT (component), name, widget) + +GtkWidget* +create_config_win (void) +{ + GtkWidget *config_win; + GtkWidget *config_vbox; + GtkWidget *config_notebook; + GtkWidget *config_output_page; + GtkWidget *output_options_hbox; + GtkWidget *output_resampling_frame; + GtkWidget *output_resampling_table; + GtkWidget *resampling_rate_hbox; + GtkWidget *resampling_rate_label; + GtkWidget *resampling_quality_hbox; + GtkWidget *resampling_quality_label; + GtkWidget *resampling_rate_optionmenu; + GtkWidget *resampling_quality_optionmenu; + GtkWidget *output_resampling_label; + GtkWidget *output_notebook; + GtkWidget *output_plugin_page; + GtkWidget *op_plugin_frame; + GtkWidget *op_plugin_vbox; + GtkWidget *op_plugin_optionmenu; + GtkWidget *convertwidget5; + GtkWidget *convertwidget6; + GtkWidget *op_plugin_buttonbox; + GtkWidget *op_configure_button; + GtkWidget *op_about_button; + GtkWidget *label8; + GtkWidget *op_options_frame; + GtkWidget *op_options_vbox; + GtkWidget *op_throttle_check; + GtkWidget *op_maxblock_hbox; + GtkWidget *op_maxblock_check; + GtkObject *op_maxblock_spin_adj; + GtkWidget *op_maxblock_spin; + GtkWidget *op_forcereopen_check; + GtkWidget *label9; + GtkWidget *label31; + GtkWidget *empty_notebook_page; + GtkWidget *label32; + GtkWidget *label33; + GtkWidget *label34; + GtkWidget *output_help_label; + GtkWidget *config_devices_label; + GtkWidget *config_effects_page; + GtkWidget *ep_plugin_frame; + GtkWidget *ep_plugin_vbox; + GtkWidget *ep_plugin_optionmenu; + GtkWidget *convertwidget7; + GtkWidget *convertwidget8; + GtkWidget *ep_plugin_buttonbox; + GtkWidget *ep_configure_button; + GtkWidget *ep_about_button; + GtkWidget *ep_enable_check; + GtkWidget *label10; + GtkWidget *effects_volnorm_frame; + GtkWidget *effects_volnorm_table; + GtkWidget *volnorm_quantaudio_check; + GtkObject *volnorm_target_spin_adj; + GtkWidget *volnorm_target_spin; + GtkWidget *volnorm_target_hbox; + GtkWidget *volnorm_target_label; + GtkWidget *volnorm_enable_check; + GtkWidget *volnorm_rva2_check; + GtkWidget *label11; + GtkWidget *effects_help_label; + GtkWidget *config_effects_label; + GtkWidget *config_crossfader_page; + GtkWidget *xf_bufsize_hbox; + GtkWidget *xf_bufsize_label; + GtkObject *xf_buffer_spin_adj; + GtkWidget *xf_buffer_spin; + GtkWidget *xf_autobuf_check; + GtkWidget *xf_config_hbox; + GtkWidget *xf_config_label; + GtkWidget *xf_config_optionmenu; + GtkWidget *convertwidget9; + GtkWidget *convertwidget10; + GtkWidget *xf_type_hbox; + GtkWidget *xf_type_label; + GtkWidget *xf_type_optionmenu; + GtkWidget *convertwidget11; + GtkWidget *convertwidget12; + GtkWidget *xf_type_notebook; + GtkWidget *xft_reopen_label; + GtkWidget *xft_flush_page; + GtkWidget *xftf_pause_frame; + GtkWidget *xftf_pause_table; + GtkWidget *xftfp_length_label; + GtkObject *xftfp_length_spin_adj; + GtkWidget *xftfp_length_spin; + GtkWidget *xftfp_enable_check; + GtkWidget *label12; + GtkWidget *xftf_fadein_frame; + GtkWidget *xftf_fadein_table; + GtkWidget *xftffi_length_hbox; + GtkWidget *xftffi_length_label; + GtkWidget *xftffi_volume_hbox; + GtkWidget *xftffi_volume_label; + GtkObject *xftffi_length_spin_adj; + GtkWidget *xftffi_length_spin; + GtkWidget *xftffi_enable_check; + GtkObject *xftffi_volume_spin_adj; + GtkWidget *xftffi_volume_spin; + GtkWidget *label13; + GtkWidget *xft_flush_label; + GtkWidget *xft_none_label; + GtkWidget *xft_pause_page; + GtkWidget *xf_pause_frame; + GtkWidget *xf_pause_table; + GtkWidget *pause_length_hbox; + GtkWidget *pause_length_label; + GtkObject *pause_length_spin_adj; + GtkWidget *pause_length_spin; + GtkWidget *label14; + GtkWidget *xft_pause_label; + GtkWidget *xft_simplexf_page; + GtkWidget *xf_simple_frame; + GtkWidget *xf_simple_table; + GtkWidget *simple_length_hbox; + GtkWidget *simple_length_label; + GtkObject *simple_length_spin_adj; + GtkWidget *simple_length_spin; + GtkWidget *label15; + GtkWidget *xft_simplexf_label; + GtkWidget *xft_advancedxf_page; + GtkWidget *xf_fadeout_frame; + GtkWidget *xf_fadeout_table; + GtkWidget *fadeout_length_hbox; + GtkWidget *fadeout_length_label; + GtkObject *fadeout_length_spin_adj; + GtkWidget *fadeout_length_spin; + GtkWidget *fadeout_volume_hbox; + GtkWidget *fadeout_volume_label; + GtkObject *fadeout_volume_spin_adj; + GtkWidget *fadeout_volume_spin; + GtkWidget *fadeout_options_hbox; + GtkWidget *fadeout_enable_check; + GtkWidget *label16; + GtkWidget *xf_offset_frame; + GtkWidget *xf_offset_table; + GtkWidget *xfofs_custom_hbox; + GtkWidget *xfofs_custom_radiobutton; + GSList *xfofs_custom_radiobutton_group = NULL; + GtkObject *xfofs_custom_spin_adj; + GtkWidget *xfofs_custom_spin; + GtkWidget *xfofs_none_radiobutton; + GtkWidget *xfofs_lockout_radiobutton; + GtkWidget *xfofs_lockin_radiobutton; + GtkWidget *label17; + GtkWidget *xf_fadein_frame; + GtkWidget *xf_fadein_table; + GtkWidget *fadein_length_hbox; + GtkWidget *fadein_length_label; + GtkWidget *fadein_volume_hbox; + GtkWidget *fadein_volume_label; + GtkObject *fadein_length_spin_adj; + GtkWidget *fadein_length_spin; + GtkWidget *fadein_enable_check; + GtkWidget *fadein_lock_check; + GtkObject *fadein_volume_spin_adj; + GtkWidget *fadein_volume_spin; + GtkWidget *label18; + GtkWidget *xft_advancedxf_label; + GtkWidget *xft_fadein_page; + GtkWidget *xftfi_fadein_frame; + GtkWidget *xftfi_fadein_table; + GtkWidget *xftfi_length_hbox; + GtkWidget *xftfi_length_label; + GtkWidget *xftfi_volume_hbox; + GtkWidget *xftfi_volume_label; + GtkObject *xftfi_length_spin_adj; + GtkWidget *xftfi_length_spin; + GtkObject *xftfi_volume_spin_adj; + GtkWidget *xftfi_volume_spin; + GtkWidget *label19; + GtkWidget *xft_fadein_label; + GtkWidget *xft_fadeout_page; + GtkWidget *xftfo_fadeout_frame; + GtkWidget *xftfo_fadeout_table; + GtkWidget *xftfo_length_hbox; + GtkWidget *xftfo_length_label; + GtkObject *xftfo_length_spin_adj; + GtkWidget *xftfo_length_spin; + GtkWidget *xftfo_volume_hbox; + GtkWidget *xftfo_volume_label; + GtkObject *xftfo_volume_spin_adj; + GtkWidget *xftfo_volume_spin; + GtkWidget *label20; + GtkWidget *xftfo_silence_frame; + GtkWidget *xftfo_silence_table; + GtkWidget *xftfo_silence_hbox; + GtkWidget *xftfo_silence_label; + GtkObject *xftfo_silence_spin_adj; + GtkWidget *xftfo_silence_spin; + GtkWidget *label21; + GtkWidget *xft_fadeout_label; + GtkWidget *xft_pause_none_label; + GtkWidget *xft_pause_adv_page; + GtkWidget *xft_fadeoutin_frame; + GtkWidget *xft_fadeoutin_table; + GtkObject *xftfoi_fadeout_spin_adj; + GtkWidget *xftfoi_fadeout_spin; + GtkObject *xftfoi_silence_spin_adj; + GtkWidget *xftfoi_silence_spin; + GtkObject *xftfoi_fadein_spin_adj; + GtkWidget *xftfoi_fadein_spin; + GtkWidget *xftfoi_fadein_hbox; + GtkWidget *xftfoi_fadein_label; + GtkWidget *xftfoi_silence_hbox; + GtkWidget *xftfoi_silence_label; + GtkWidget *xftfoi_fadeout_hbox; + GtkWidget *xftfoi_fadeout_label; + GtkWidget *label22; + GtkWidget *xft_pause_adv_label; + GtkWidget *config_crossfade_label; + GtkWidget *config_gapkiller_page; + GtkWidget *gap_leading_frame; + GtkWidget *gap_leading_table; + GtkObject *lgap_length_spin_adj; + GtkWidget *lgap_length_spin; + GtkObject *lgap_level_spin_adj; + GtkWidget *lgap_level_spin; + GtkWidget *lgap_length_hbox; + GtkWidget *lgap_length_label; + GtkWidget *lgap_level_hbox; + GtkWidget *lgap_level_label; + GtkWidget *lgap_enable_check; + GtkWidget *label23; + GtkWidget *gap_trailing_frame; + GtkWidget *gap_trailing_table; + GtkWidget *tgap_length_hbox; + GtkWidget *tgap_length_label; + GtkWidget *tgap_level_hbox; + GtkWidget *tgap_level_label; + GtkObject *tgap_length_spin_adj; + GtkWidget *tgap_length_spin; + GtkObject *tgap_level_spin_adj; + GtkWidget *tgap_level_spin; + GtkWidget *tgap_lock_check; + GtkWidget *tgap_enable_check; + GtkWidget *label24; + GtkWidget *gap_advanced_frame; + GtkWidget *gap_advanced_vbox; + GtkWidget *gadv_crossing_check; + GtkWidget *label25; + GtkWidget *config_gapkiller_label; + GtkWidget *config_misc_page; + GtkWidget *misc_debug_frame; + GtkWidget *misc_debug_vbox; + GtkWidget *debug_stderr_check; + GtkWidget *debug_monitor_check; + GtkWidget *label26; + GtkWidget *misc_mixopt_frame; + GtkWidget *misc_mixopt_vbox; + GtkWidget *mixopt_enable_check; + GtkWidget *mixopt_reverse_check; + GtkWidget *mixopt_software_check; + GtkWidget *label27; + GtkWidget *misc_other_frame; + GtkWidget *misc_other_vbox; + GtkWidget *moth_songchange_hbox; + GtkWidget *moth_songchange_label; + GtkObject *moth_songchange_spin_adj; + GtkWidget *moth_songchange_spin; + GtkWidget *moth_preload_hbox; + GtkWidget *moth_preload_label; + GtkObject *moth_preload_spin_adj; + GtkWidget *moth_preload_spin; + GtkWidget *moth_noxf_hbox; + GtkWidget *moth_noxf_label; + GtkWidget *noxf_album_check; + GtkWidget *noxf_samefile_check; + GtkWidget *moth_httpworkaround_check; + GtkWidget *moth_opmaxused_hbox; + GtkWidget *moth_opmaxused_check; + GtkObject *moth_opmaxused_spin_adj; + GtkWidget *moth_opmaxused_spin; + GtkWidget *moth_quantaudio_check; + GtkWidget *moth_outputkeepopened_check; + GtkWidget *label28; + GtkWidget *config_misc_label; + GtkWidget *config_presets_page; + GtkWidget *presets_name_hbox; + GtkWidget *presets_name_entry; + GtkWidget *presets_delete_button; + GtkWidget *presets_new_button; + GtkWidget *presets_list_scrolledwindow; + GtkWidget *presets_list_list; + GtkWidget *presets_list_bbox; + GtkWidget *presets_load_button; + GtkWidget *presets_save_button; + GtkWidget *config_presets_label; + GtkWidget *config_bbox; + GtkWidget *config_ok; + GtkWidget *config_cancel; + GtkWidget *config_apply; + GtkTooltips *tooltips; + + tooltips = gtk_tooltips_new (); + + config_win = gtk_window_new (GTK_WINDOW_TOPLEVEL); + gtk_window_set_title (GTK_WINDOW (config_win), "Crossfade Configuration"); + + config_vbox = gtk_vbox_new (FALSE, 10); + gtk_widget_show (config_vbox); + gtk_container_add (GTK_CONTAINER (config_win), config_vbox); + gtk_container_set_border_width (GTK_CONTAINER (config_vbox), 10); + + config_notebook = gtk_notebook_new (); + gtk_widget_show (config_notebook); + gtk_box_pack_start (GTK_BOX (config_vbox), config_notebook, TRUE, TRUE, 0); + + config_output_page = gtk_vbox_new (FALSE, 5); + gtk_widget_show (config_output_page); + gtk_container_add (GTK_CONTAINER (config_notebook), config_output_page); + gtk_container_set_border_width (GTK_CONTAINER (config_output_page), 5); + + output_options_hbox = gtk_hbox_new (FALSE, 6); + gtk_widget_show (output_options_hbox); + gtk_box_pack_start (GTK_BOX (config_output_page), output_options_hbox, FALSE, TRUE, 0); + + output_resampling_frame = gtk_frame_new (NULL); + gtk_widget_show (output_resampling_frame); + gtk_box_pack_start (GTK_BOX (output_options_hbox), output_resampling_frame, FALSE, FALSE, 0); + + output_resampling_table = gtk_table_new (2, 2, FALSE); + gtk_widget_show (output_resampling_table); + gtk_container_add (GTK_CONTAINER (output_resampling_frame), output_resampling_table); + gtk_container_set_border_width (GTK_CONTAINER (output_resampling_table), 5); + gtk_table_set_row_spacings (GTK_TABLE (output_resampling_table), 2); + gtk_table_set_col_spacings (GTK_TABLE (output_resampling_table), 2); + + resampling_rate_hbox = gtk_hbox_new (FALSE, 0); + gtk_widget_show (resampling_rate_hbox); + gtk_table_attach (GTK_TABLE (output_resampling_table), resampling_rate_hbox, 0, 1, 0, 1, + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); + + resampling_rate_label = gtk_label_new ("Rate:"); + gtk_widget_show (resampling_rate_label); + gtk_box_pack_end (GTK_BOX (resampling_rate_hbox), resampling_rate_label, FALSE, FALSE, 0); + + resampling_quality_hbox = gtk_hbox_new (FALSE, 0); + gtk_widget_show (resampling_quality_hbox); + gtk_table_attach (GTK_TABLE (output_resampling_table), resampling_quality_hbox, 0, 1, 1, 2, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); + + resampling_quality_label = gtk_label_new ("Quality:"); + gtk_widget_show (resampling_quality_label); + gtk_box_pack_end (GTK_BOX (resampling_quality_hbox), resampling_quality_label, FALSE, FALSE, 0); + + resampling_rate_optionmenu = gtk_option_menu_new (); + gtk_widget_show (resampling_rate_optionmenu); + gtk_table_attach (GTK_TABLE (output_resampling_table), resampling_rate_optionmenu, 1, 2, 0, 1, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + + resampling_quality_optionmenu = gtk_option_menu_new (); + gtk_widget_show (resampling_quality_optionmenu); + gtk_table_attach (GTK_TABLE (output_resampling_table), resampling_quality_optionmenu, 1, 2, 1, 2, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + + output_resampling_label = gtk_label_new ("Resampling"); + gtk_widget_show (output_resampling_label); + gtk_frame_set_label_widget (GTK_FRAME (output_resampling_frame), output_resampling_label); + + output_notebook = gtk_notebook_new (); + gtk_widget_show (output_notebook); + gtk_box_pack_start (GTK_BOX (config_output_page), output_notebook, FALSE, TRUE, 0); + GTK_WIDGET_UNSET_FLAGS (output_notebook, GTK_CAN_FOCUS); + gtk_notebook_set_show_tabs (GTK_NOTEBOOK (output_notebook), FALSE); + gtk_notebook_set_show_border (GTK_NOTEBOOK (output_notebook), FALSE); + + output_plugin_page = gtk_vbox_new (FALSE, 5); + gtk_widget_show (output_plugin_page); + gtk_container_add (GTK_CONTAINER (output_notebook), output_plugin_page); + + op_plugin_frame = gtk_frame_new (NULL); + gtk_widget_show (op_plugin_frame); + gtk_box_pack_start (GTK_BOX (output_plugin_page), op_plugin_frame, FALSE, TRUE, 0); + + op_plugin_vbox = gtk_vbox_new (FALSE, 2); + gtk_widget_show (op_plugin_vbox); + gtk_container_add (GTK_CONTAINER (op_plugin_frame), op_plugin_vbox); + gtk_container_set_border_width (GTK_CONTAINER (op_plugin_vbox), 5); + + op_plugin_optionmenu = gtk_option_menu_new (); + gtk_widget_show (op_plugin_optionmenu); + gtk_box_pack_start (GTK_BOX (op_plugin_vbox), op_plugin_optionmenu, FALSE, FALSE, 0); + + convertwidget5 = gtk_menu_new (); + + convertwidget6 = gtk_menu_item_new_with_mnemonic ("dummy"); + gtk_widget_show (convertwidget6); + gtk_container_add (GTK_CONTAINER (convertwidget5), convertwidget6); + + gtk_option_menu_set_menu (GTK_OPTION_MENU (op_plugin_optionmenu), convertwidget5); + + op_plugin_buttonbox = gtk_hbutton_box_new (); + gtk_widget_show (op_plugin_buttonbox); + gtk_box_pack_start (GTK_BOX (op_plugin_vbox), op_plugin_buttonbox, FALSE, TRUE, 0); + gtk_button_box_set_layout (GTK_BUTTON_BOX (op_plugin_buttonbox), GTK_BUTTONBOX_START); + gtk_box_set_spacing (GTK_BOX (op_plugin_buttonbox), 5); + + op_configure_button = gtk_button_new_with_mnemonic ("Configure"); + gtk_widget_show (op_configure_button); + gtk_container_add (GTK_CONTAINER (op_plugin_buttonbox), op_configure_button); + GTK_WIDGET_SET_FLAGS (op_configure_button, GTK_CAN_DEFAULT); + + op_about_button = gtk_button_new_with_mnemonic ("About"); + gtk_widget_show (op_about_button); + gtk_container_add (GTK_CONTAINER (op_plugin_buttonbox), op_about_button); + GTK_WIDGET_SET_FLAGS (op_about_button, GTK_CAN_DEFAULT); + + label8 = gtk_label_new ("Output plugin"); + gtk_widget_show (label8); + gtk_frame_set_label_widget (GTK_FRAME (op_plugin_frame), label8); + + op_options_frame = gtk_frame_new (NULL); + gtk_widget_show (op_options_frame); + gtk_box_pack_start (GTK_BOX (output_plugin_page), op_options_frame, FALSE, TRUE, 0); + + op_options_vbox = gtk_vbox_new (FALSE, 2); + gtk_widget_show (op_options_vbox); + gtk_container_add (GTK_CONTAINER (op_options_frame), op_options_vbox); + gtk_container_set_border_width (GTK_CONTAINER (op_options_vbox), 5); + + op_throttle_check = gtk_check_button_new_with_mnemonic ("Throttle Output"); + gtk_widget_show (op_throttle_check); + gtk_box_pack_start (GTK_BOX (op_options_vbox), op_throttle_check, FALSE, FALSE, 0); + + op_maxblock_hbox = gtk_hbox_new (FALSE, 5); + gtk_widget_show (op_maxblock_hbox); + gtk_box_pack_start (GTK_BOX (op_options_vbox), op_maxblock_hbox, TRUE, TRUE, 0); + + op_maxblock_check = gtk_check_button_new_with_mnemonic ("Max block size (bytes):"); + gtk_widget_show (op_maxblock_check); + gtk_box_pack_start (GTK_BOX (op_maxblock_hbox), op_maxblock_check, FALSE, FALSE, 0); + + op_maxblock_spin_adj = gtk_adjustment_new (1024, 4, 1048580, 4, 16, 10); + op_maxblock_spin = gtk_spin_button_new (GTK_ADJUSTMENT (op_maxblock_spin_adj), 10, 0); + gtk_widget_show (op_maxblock_spin); + gtk_box_pack_start (GTK_BOX (op_maxblock_hbox), op_maxblock_spin, TRUE, TRUE, 0); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (op_maxblock_spin), TRUE); + gtk_spin_button_set_snap_to_ticks (GTK_SPIN_BUTTON (op_maxblock_spin), TRUE); + + op_forcereopen_check = gtk_check_button_new_with_mnemonic ("Force close/reopen on songchange"); + gtk_widget_show (op_forcereopen_check); + gtk_box_pack_start (GTK_BOX (op_options_vbox), op_forcereopen_check, FALSE, FALSE, 0); + + label9 = gtk_label_new ("Plugin compatibility options"); + gtk_widget_show (label9); + gtk_frame_set_label_widget (GTK_FRAME (op_options_frame), label9); + + label31 = gtk_label_new (""); + gtk_widget_show (label31); + gtk_notebook_set_tab_label (GTK_NOTEBOOK (output_notebook), gtk_notebook_get_nth_page (GTK_NOTEBOOK (output_notebook), 0), label31); + + empty_notebook_page = gtk_vbox_new (FALSE, 0); + gtk_widget_show (empty_notebook_page); + gtk_container_add (GTK_CONTAINER (output_notebook), empty_notebook_page); + + label32 = gtk_label_new (""); + gtk_widget_show (label32); + gtk_notebook_set_tab_label (GTK_NOTEBOOK (output_notebook), gtk_notebook_get_nth_page (GTK_NOTEBOOK (output_notebook), 1), label32); + + empty_notebook_page = gtk_vbox_new (FALSE, 0); + gtk_widget_show (empty_notebook_page); + gtk_container_add (GTK_CONTAINER (output_notebook), empty_notebook_page); + + label33 = gtk_label_new (""); + gtk_widget_show (label33); + gtk_notebook_set_tab_label (GTK_NOTEBOOK (output_notebook), gtk_notebook_get_nth_page (GTK_NOTEBOOK (output_notebook), 2), label33); + + empty_notebook_page = gtk_vbox_new (FALSE, 0); + gtk_widget_show (empty_notebook_page); + gtk_container_add (GTK_CONTAINER (output_notebook), empty_notebook_page); + + label34 = gtk_label_new (""); + gtk_widget_show (label34); + gtk_notebook_set_tab_label (GTK_NOTEBOOK (output_notebook), gtk_notebook_get_nth_page (GTK_NOTEBOOK (output_notebook), 3), label34); + + output_help_label = gtk_label_new ("When modifying the Output Options or the Mixing buffer size, you need to stop/restart playback for the settings to take effect."); + gtk_widget_show (output_help_label); + gtk_box_pack_end (GTK_BOX (config_output_page), output_help_label, TRUE, TRUE, 0); + gtk_label_set_line_wrap (GTK_LABEL (output_help_label), TRUE); + + config_devices_label = gtk_label_new ("Output"); + gtk_widget_show (config_devices_label); + gtk_notebook_set_tab_label (GTK_NOTEBOOK (config_notebook), gtk_notebook_get_nth_page (GTK_NOTEBOOK (config_notebook), 0), config_devices_label); + gtk_label_set_justify (GTK_LABEL (config_devices_label), GTK_JUSTIFY_CENTER); + + config_effects_page = gtk_vbox_new (FALSE, 5); + gtk_widget_show (config_effects_page); + gtk_container_add (GTK_CONTAINER (config_notebook), config_effects_page); + gtk_container_set_border_width (GTK_CONTAINER (config_effects_page), 5); + + ep_plugin_frame = gtk_frame_new (NULL); + gtk_widget_show (ep_plugin_frame); + gtk_box_pack_start (GTK_BOX (config_effects_page), ep_plugin_frame, FALSE, TRUE, 0); + + ep_plugin_vbox = gtk_vbox_new (FALSE, 2); + gtk_widget_show (ep_plugin_vbox); + gtk_container_add (GTK_CONTAINER (ep_plugin_frame), ep_plugin_vbox); + gtk_container_set_border_width (GTK_CONTAINER (ep_plugin_vbox), 5); + + ep_plugin_optionmenu = gtk_option_menu_new (); + gtk_widget_show (ep_plugin_optionmenu); + gtk_box_pack_start (GTK_BOX (ep_plugin_vbox), ep_plugin_optionmenu, FALSE, FALSE, 0); + gtk_tooltips_set_tip (tooltips, ep_plugin_optionmenu, "Select an effect plugin. Take care not to use the same plugin as selected in XMMS' configuration dialog.", NULL); + + convertwidget7 = gtk_menu_new (); + + convertwidget8 = gtk_menu_item_new_with_mnemonic ("dummy"); + gtk_widget_show (convertwidget8); + gtk_container_add (GTK_CONTAINER (convertwidget7), convertwidget8); + + gtk_option_menu_set_menu (GTK_OPTION_MENU (ep_plugin_optionmenu), convertwidget7); + + ep_plugin_buttonbox = gtk_hbutton_box_new (); + gtk_widget_show (ep_plugin_buttonbox); + gtk_box_pack_start (GTK_BOX (ep_plugin_vbox), ep_plugin_buttonbox, FALSE, TRUE, 0); + gtk_button_box_set_layout (GTK_BUTTON_BOX (ep_plugin_buttonbox), GTK_BUTTONBOX_START); + gtk_box_set_spacing (GTK_BOX (ep_plugin_buttonbox), 5); + + ep_configure_button = gtk_button_new_with_mnemonic ("Configure"); + gtk_widget_show (ep_configure_button); + gtk_container_add (GTK_CONTAINER (ep_plugin_buttonbox), ep_configure_button); + GTK_WIDGET_SET_FLAGS (ep_configure_button, GTK_CAN_DEFAULT); + gtk_tooltips_set_tip (tooltips, ep_configure_button, "Open the configuration dialog of the plugin selected above.", NULL); + + ep_about_button = gtk_button_new_with_mnemonic ("About"); + gtk_widget_show (ep_about_button); + gtk_container_add (GTK_CONTAINER (ep_plugin_buttonbox), ep_about_button); + GTK_WIDGET_SET_FLAGS (ep_about_button, GTK_CAN_DEFAULT); + gtk_tooltips_set_tip (tooltips, ep_about_button, "Open the about dialog of the plugin selected above.", NULL); + + ep_enable_check = gtk_check_button_new_with_mnemonic ("Use plugin"); + gtk_widget_show (ep_enable_check); + gtk_container_add (GTK_CONTAINER (ep_plugin_buttonbox), ep_enable_check); + gtk_tooltips_set_tip (tooltips, ep_enable_check, "Enable the selected plugin. Note that after pressing 'Apply' it may take a while until you can hear the effect, since it is applied before the audio data goes into the buffer.", NULL); + + label10 = gtk_label_new ("Pre-mixing effect plugin"); + gtk_widget_show (label10); + gtk_frame_set_label_widget (GTK_FRAME (ep_plugin_frame), label10); + + effects_volnorm_frame = gtk_frame_new (NULL); + gtk_box_pack_start (GTK_BOX (config_effects_page), effects_volnorm_frame, FALSE, FALSE, 0); + + effects_volnorm_table = gtk_table_new (4, 2, FALSE); + gtk_widget_show (effects_volnorm_table); + gtk_container_add (GTK_CONTAINER (effects_volnorm_frame), effects_volnorm_table); + gtk_container_set_border_width (GTK_CONTAINER (effects_volnorm_table), 5); + gtk_table_set_row_spacings (GTK_TABLE (effects_volnorm_table), 2); + gtk_table_set_col_spacings (GTK_TABLE (effects_volnorm_table), 5); + + volnorm_quantaudio_check = gtk_check_button_new_with_mnemonic ("Read Quantaudio comment field"); + gtk_widget_show (volnorm_quantaudio_check); + gtk_table_attach (GTK_TABLE (effects_volnorm_table), volnorm_quantaudio_check, 1, 2, 2, 3, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + + volnorm_target_spin_adj = gtk_adjustment_new (8000, 0, 32768, 100, 1000, 10); + volnorm_target_spin = gtk_spin_button_new (GTK_ADJUSTMENT (volnorm_target_spin_adj), 0, 0); + gtk_widget_show (volnorm_target_spin); + gtk_table_attach (GTK_TABLE (effects_volnorm_table), volnorm_target_spin, 1, 2, 3, 4, + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + gtk_tooltips_set_tip (tooltips, volnorm_target_spin, "Set the maximum length for gaps at the end of a stream.\nDefault: 500", NULL); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (volnorm_target_spin), TRUE); + + volnorm_target_hbox = gtk_hbox_new (FALSE, 0); + gtk_widget_show (volnorm_target_hbox); + gtk_table_attach (GTK_TABLE (effects_volnorm_table), volnorm_target_hbox, 0, 1, 3, 4, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (GTK_FILL), 0, 0); + + volnorm_target_label = gtk_label_new ("Target RMS:"); + gtk_widget_show (volnorm_target_label); + gtk_box_pack_start (GTK_BOX (volnorm_target_hbox), volnorm_target_label, FALSE, FALSE, 0); + gtk_label_set_justify (GTK_LABEL (volnorm_target_label), GTK_JUSTIFY_CENTER); + + volnorm_enable_check = gtk_check_button_new_with_mnemonic ("Enable"); + gtk_widget_show (volnorm_enable_check); + gtk_table_attach (GTK_TABLE (effects_volnorm_table), volnorm_enable_check, 1, 2, 0, 1, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + + volnorm_rva2_check = gtk_check_button_new_with_mnemonic ("Read ID3V2 RVA2 Tag"); + gtk_widget_show (volnorm_rva2_check); + gtk_table_attach (GTK_TABLE (effects_volnorm_table), volnorm_rva2_check, 1, 2, 1, 2, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + + label11 = gtk_label_new ("Volume normalizer"); + gtk_widget_show (label11); + gtk_frame_set_label_widget (GTK_FRAME (effects_volnorm_frame), label11); + + effects_help_label = gtk_label_new ("You do not need to press 'Apply' after making changes to the effect plugin settings. It may take a while though until you can hear the change, since the plugin is applied before the mixing buffer."); + gtk_widget_show (effects_help_label); + gtk_box_pack_start (GTK_BOX (config_effects_page), effects_help_label, TRUE, TRUE, 0); + gtk_label_set_line_wrap (GTK_LABEL (effects_help_label), TRUE); + + config_effects_label = gtk_label_new ("Effects"); + gtk_widget_show (config_effects_label); + gtk_notebook_set_tab_label (GTK_NOTEBOOK (config_notebook), gtk_notebook_get_nth_page (GTK_NOTEBOOK (config_notebook), 1), config_effects_label); + gtk_label_set_justify (GTK_LABEL (config_effects_label), GTK_JUSTIFY_CENTER); + + config_crossfader_page = gtk_vbox_new (FALSE, 2); + gtk_widget_show (config_crossfader_page); + gtk_container_add (GTK_CONTAINER (config_notebook), config_crossfader_page); + gtk_container_set_border_width (GTK_CONTAINER (config_crossfader_page), 5); + + xf_bufsize_hbox = gtk_hbox_new (FALSE, 5); + gtk_widget_show (xf_bufsize_hbox); + gtk_box_pack_start (GTK_BOX (config_crossfader_page), xf_bufsize_hbox, FALSE, FALSE, 0); + + xf_bufsize_label = gtk_label_new ("Mixing buffer size (ms):"); + gtk_widget_show (xf_bufsize_label); + gtk_box_pack_start (GTK_BOX (xf_bufsize_hbox), xf_bufsize_label, FALSE, FALSE, 0); + gtk_label_set_justify (GTK_LABEL (xf_bufsize_label), GTK_JUSTIFY_CENTER); + + xf_buffer_spin_adj = gtk_adjustment_new (8500, 0, 60000, 100, 1000, 10); + xf_buffer_spin = gtk_spin_button_new (GTK_ADJUSTMENT (xf_buffer_spin_adj), 0, 0); + gtk_widget_show (xf_buffer_spin); + gtk_box_pack_start (GTK_BOX (xf_bufsize_hbox), xf_buffer_spin, TRUE, TRUE, 0); + gtk_tooltips_set_tip (tooltips, xf_buffer_spin, "Specify the size of the mixing buffer. Mixing buffer space is required for pauses, fade-outs, offsetting (i.e. interleaving the end and beginning of two songs) and killing trailing gaps. Fade-ins and killing leading gaps are done on-the-fly and do not depend on mixing buffer space.\nDefault: n/a - calculated automatically", NULL); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (xf_buffer_spin), TRUE); + + xf_autobuf_check = gtk_check_button_new_with_mnemonic ("auto"); + gtk_widget_show (xf_autobuf_check); + gtk_box_pack_start (GTK_BOX (xf_bufsize_hbox), xf_autobuf_check, FALSE, FALSE, 0); + gtk_tooltips_set_tip (tooltips, xf_autobuf_check, "Automatically calculate an optimal buffer size.\nDefault: On", NULL); + + xf_config_hbox = gtk_hbox_new (FALSE, 5); + gtk_widget_show (xf_config_hbox); + gtk_box_pack_start (GTK_BOX (config_crossfader_page), xf_config_hbox, FALSE, FALSE, 0); + + xf_config_label = gtk_label_new ("Set parameters for:"); + gtk_widget_show (xf_config_label); + gtk_box_pack_start (GTK_BOX (xf_config_hbox), xf_config_label, FALSE, FALSE, 0); + gtk_label_set_justify (GTK_LABEL (xf_config_label), GTK_JUSTIFY_CENTER); + + xf_config_optionmenu = gtk_option_menu_new (); + gtk_widget_show (xf_config_optionmenu); + gtk_box_pack_start (GTK_BOX (xf_config_hbox), xf_config_optionmenu, TRUE, TRUE, 0); + gtk_tooltips_set_tip (tooltips, xf_config_optionmenu, "Select the type of songchange you want to configure:\n* Start of playback: When starting playback by pressing PLAY\n* Automatic songchange: When reaching the end of a song and the playlist advances to the next song\n* Manual songchange: When manually selecting another song, for example by pressing NEXT/PREV\n* Manual stop: When pressing the STOP button\n* End of playlist: After the last song in the playlist has been played\n* Seeking: When seeking within the current song", NULL); + + convertwidget9 = gtk_menu_new (); + + convertwidget10 = gtk_menu_item_new_with_mnemonic ("dummy"); + gtk_widget_show (convertwidget10); + gtk_container_add (GTK_CONTAINER (convertwidget9), convertwidget10); + + gtk_option_menu_set_menu (GTK_OPTION_MENU (xf_config_optionmenu), convertwidget9); + + xf_type_hbox = gtk_hbox_new (FALSE, 5); + gtk_widget_show (xf_type_hbox); + gtk_box_pack_start (GTK_BOX (config_crossfader_page), xf_type_hbox, FALSE, FALSE, 0); + + xf_type_label = gtk_label_new ("Crossfade/Transition type:"); + gtk_widget_show (xf_type_label); + gtk_box_pack_start (GTK_BOX (xf_type_hbox), xf_type_label, FALSE, FALSE, 0); + gtk_label_set_justify (GTK_LABEL (xf_type_label), GTK_JUSTIFY_CENTER); + + xf_type_optionmenu = gtk_option_menu_new (); + gtk_widget_show (xf_type_optionmenu); + gtk_box_pack_start (GTK_BOX (xf_type_hbox), xf_type_optionmenu, TRUE, TRUE, 0); + gtk_tooltips_set_tip (tooltips, xf_type_optionmenu, "Select the transition to be used for the songchange type selected above:\n* Fade-in: Fade-in at 'Start of playback'\n* Reopen output device: Force a close/open on the output plugin. This will most certainly re-introduce gaps and clicks, but might be usefull with some plugins.\n* Flush output device: Keeps the output plugin opened, but flushes its buffers. This will give you almost instant reaction when pressing NEXT/PREV.\n* None (gapless/off): Gapless mode. Keeps the device opened, but does not do any fading.\n* Simple crossfade: Does a simple crossfade between the previous and the next song.\n* Advanced crossfade: Allows you to configure the crossfade in more detail.\n* Fade-out: Fade-out at 'Manual stop' or 'End of playlist'.", NULL); + + convertwidget11 = gtk_menu_new (); + + convertwidget12 = gtk_menu_item_new_with_mnemonic ("dummy"); + gtk_widget_show (convertwidget12); + gtk_container_add (GTK_CONTAINER (convertwidget11), convertwidget12); + + gtk_option_menu_set_menu (GTK_OPTION_MENU (xf_type_optionmenu), convertwidget11); + + xf_type_notebook = gtk_notebook_new (); + gtk_widget_show (xf_type_notebook); + gtk_box_pack_start (GTK_BOX (config_crossfader_page), xf_type_notebook, FALSE, FALSE, 0); + GTK_WIDGET_UNSET_FLAGS (xf_type_notebook, GTK_CAN_FOCUS); + gtk_notebook_set_show_tabs (GTK_NOTEBOOK (xf_type_notebook), FALSE); + gtk_notebook_set_show_border (GTK_NOTEBOOK (xf_type_notebook), FALSE); + + empty_notebook_page = gtk_vbox_new (FALSE, 0); + gtk_widget_show (empty_notebook_page); + gtk_container_add (GTK_CONTAINER (xf_type_notebook), empty_notebook_page); + + xft_reopen_label = gtk_label_new ("Reopen"); + gtk_widget_show (xft_reopen_label); + gtk_notebook_set_tab_label (GTK_NOTEBOOK (xf_type_notebook), gtk_notebook_get_nth_page (GTK_NOTEBOOK (xf_type_notebook), 0), xft_reopen_label); + gtk_label_set_justify (GTK_LABEL (xft_reopen_label), GTK_JUSTIFY_CENTER); + + xft_flush_page = gtk_vbox_new (FALSE, 5); + gtk_widget_show (xft_flush_page); + gtk_container_add (GTK_CONTAINER (xf_type_notebook), xft_flush_page); + + xftf_pause_frame = gtk_frame_new (NULL); + gtk_widget_show (xftf_pause_frame); + gtk_box_pack_start (GTK_BOX (xft_flush_page), xftf_pause_frame, FALSE, FALSE, 0); + + xftf_pause_table = gtk_table_new (2, 2, FALSE); + gtk_widget_show (xftf_pause_table); + gtk_container_add (GTK_CONTAINER (xftf_pause_frame), xftf_pause_table); + gtk_container_set_border_width (GTK_CONTAINER (xftf_pause_table), 5); + gtk_table_set_row_spacings (GTK_TABLE (xftf_pause_table), 2); + gtk_table_set_col_spacings (GTK_TABLE (xftf_pause_table), 5); + + xftfp_length_label = gtk_label_new ("Length (ms):"); + gtk_widget_show (xftfp_length_label); + gtk_table_attach (GTK_TABLE (xftf_pause_table), xftfp_length_label, 0, 1, 1, 2, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + + xftfp_length_spin_adj = gtk_adjustment_new (1000, 0, 60000, 100, 1000, 10); + xftfp_length_spin = gtk_spin_button_new (GTK_ADJUSTMENT (xftfp_length_spin_adj), 0, 0); + gtk_widget_show (xftfp_length_spin); + gtk_table_attach (GTK_TABLE (xftf_pause_table), xftfp_length_spin, 1, 2, 1, 2, + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + gtk_tooltips_set_tip (tooltips, xftfp_length_spin, "Specify the length of the silence to be inserted between the tracks.\nDefault: 2000", NULL); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (xftfp_length_spin), TRUE); + + xftfp_enable_check = gtk_check_button_new_with_mnemonic ("Enable"); + gtk_widget_show (xftfp_enable_check); + gtk_table_attach (GTK_TABLE (xftf_pause_table), xftfp_enable_check, 1, 2, 0, 1, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + + label12 = gtk_label_new ("Pause"); + gtk_widget_show (label12); + gtk_frame_set_label_widget (GTK_FRAME (xftf_pause_frame), label12); + + xftf_fadein_frame = gtk_frame_new (NULL); + gtk_widget_show (xftf_fadein_frame); + gtk_box_pack_start (GTK_BOX (xft_flush_page), xftf_fadein_frame, FALSE, FALSE, 0); + + xftf_fadein_table = gtk_table_new (3, 2, FALSE); + gtk_widget_show (xftf_fadein_table); + gtk_container_add (GTK_CONTAINER (xftf_fadein_frame), xftf_fadein_table); + gtk_container_set_border_width (GTK_CONTAINER (xftf_fadein_table), 5); + gtk_table_set_row_spacings (GTK_TABLE (xftf_fadein_table), 2); + gtk_table_set_col_spacings (GTK_TABLE (xftf_fadein_table), 5); + + xftffi_length_hbox = gtk_hbox_new (FALSE, 0); + gtk_widget_show (xftffi_length_hbox); + gtk_table_attach (GTK_TABLE (xftf_fadein_table), xftffi_length_hbox, 0, 1, 1, 2, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); + + xftffi_length_label = gtk_label_new ("Length (ms):"); + gtk_widget_show (xftffi_length_label); + gtk_box_pack_start (GTK_BOX (xftffi_length_hbox), xftffi_length_label, FALSE, FALSE, 0); + + xftffi_volume_hbox = gtk_hbox_new (FALSE, 0); + gtk_widget_show (xftffi_volume_hbox); + gtk_table_attach (GTK_TABLE (xftf_fadein_table), xftffi_volume_hbox, 0, 1, 2, 3, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); + + xftffi_volume_label = gtk_label_new ("Start volume (%):"); + gtk_widget_show (xftffi_volume_label); + gtk_box_pack_start (GTK_BOX (xftffi_volume_hbox), xftffi_volume_label, FALSE, FALSE, 0); + + xftffi_length_spin_adj = gtk_adjustment_new (1000, 0, 60000, 100, 1000, 10); + xftffi_length_spin = gtk_spin_button_new (GTK_ADJUSTMENT (xftffi_length_spin_adj), 0, 0); + gtk_widget_show (xftffi_length_spin); + gtk_table_attach (GTK_TABLE (xftf_fadein_table), xftffi_length_spin, 1, 2, 1, 2, + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + gtk_tooltips_set_tip (tooltips, xftffi_length_spin, "Set the duration for the fadein of the next song.", NULL); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (xftffi_length_spin), TRUE); + + xftffi_enable_check = gtk_check_button_new_with_mnemonic ("Enable"); + gtk_widget_show (xftffi_enable_check); + gtk_table_attach (GTK_TABLE (xftf_fadein_table), xftffi_enable_check, 1, 2, 0, 1, + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + + xftffi_volume_spin_adj = gtk_adjustment_new (0, 0, 100, 1, 10, 10); + xftffi_volume_spin = gtk_spin_button_new (GTK_ADJUSTMENT (xftffi_volume_spin_adj), 0, 0); + gtk_widget_show (xftffi_volume_spin); + gtk_table_attach (GTK_TABLE (xftf_fadein_table), xftffi_volume_spin, 1, 2, 2, 3, + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + gtk_tooltips_set_tip (tooltips, xftffi_volume_spin, "Set the start volume. XMMS-crossfade will fade from this volume to 100% during the time specified above.\nDefault: 0", NULL); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (xftffi_volume_spin), TRUE); + + label13 = gtk_label_new ("Fade in"); + gtk_widget_show (label13); + gtk_frame_set_label_widget (GTK_FRAME (xftf_fadein_frame), label13); + + xft_flush_label = gtk_label_new ("Flush"); + gtk_widget_show (xft_flush_label); + gtk_notebook_set_tab_label (GTK_NOTEBOOK (xf_type_notebook), gtk_notebook_get_nth_page (GTK_NOTEBOOK (xf_type_notebook), 1), xft_flush_label); + gtk_label_set_justify (GTK_LABEL (xft_flush_label), GTK_JUSTIFY_CENTER); + + empty_notebook_page = gtk_vbox_new (FALSE, 0); + gtk_widget_show (empty_notebook_page); + gtk_container_add (GTK_CONTAINER (xf_type_notebook), empty_notebook_page); + + xft_none_label = gtk_label_new ("None"); + gtk_widget_show (xft_none_label); + gtk_notebook_set_tab_label (GTK_NOTEBOOK (xf_type_notebook), gtk_notebook_get_nth_page (GTK_NOTEBOOK (xf_type_notebook), 2), xft_none_label); + gtk_label_set_justify (GTK_LABEL (xft_none_label), GTK_JUSTIFY_CENTER); + + xft_pause_page = gtk_vbox_new (FALSE, 5); + gtk_widget_show (xft_pause_page); + gtk_container_add (GTK_CONTAINER (xf_type_notebook), xft_pause_page); + + xf_pause_frame = gtk_frame_new (NULL); + gtk_widget_show (xf_pause_frame); + gtk_box_pack_start (GTK_BOX (xft_pause_page), xf_pause_frame, FALSE, FALSE, 0); + + xf_pause_table = gtk_table_new (1, 2, FALSE); + gtk_widget_show (xf_pause_table); + gtk_container_add (GTK_CONTAINER (xf_pause_frame), xf_pause_table); + gtk_container_set_border_width (GTK_CONTAINER (xf_pause_table), 5); + gtk_table_set_row_spacings (GTK_TABLE (xf_pause_table), 2); + gtk_table_set_col_spacings (GTK_TABLE (xf_pause_table), 5); + + pause_length_hbox = gtk_hbox_new (FALSE, 0); + gtk_widget_show (pause_length_hbox); + gtk_table_attach (GTK_TABLE (xf_pause_table), pause_length_hbox, 0, 1, 0, 1, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); + + pause_length_label = gtk_label_new ("Length (ms):"); + gtk_widget_show (pause_length_label); + gtk_box_pack_start (GTK_BOX (pause_length_hbox), pause_length_label, FALSE, FALSE, 0); + + pause_length_spin_adj = gtk_adjustment_new (1000, 0, 60000, 100, 1000, 10); + pause_length_spin = gtk_spin_button_new (GTK_ADJUSTMENT (pause_length_spin_adj), 0, 0); + gtk_widget_show (pause_length_spin); + gtk_table_attach (GTK_TABLE (xf_pause_table), pause_length_spin, 1, 2, 0, 1, + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + gtk_tooltips_set_tip (tooltips, pause_length_spin, "Specify the length of the silence to be inserted between the tracks.\nDefault: 2000", NULL); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (pause_length_spin), TRUE); + + label14 = gtk_label_new ("Pause"); + gtk_widget_show (label14); + gtk_frame_set_label_widget (GTK_FRAME (xf_pause_frame), label14); + + xft_pause_label = gtk_label_new ("Pause"); + gtk_widget_show (xft_pause_label); + gtk_notebook_set_tab_label (GTK_NOTEBOOK (xf_type_notebook), gtk_notebook_get_nth_page (GTK_NOTEBOOK (xf_type_notebook), 3), xft_pause_label); + gtk_label_set_justify (GTK_LABEL (xft_pause_label), GTK_JUSTIFY_CENTER); + + xft_simplexf_page = gtk_vbox_new (FALSE, 5); + gtk_widget_show (xft_simplexf_page); + gtk_container_add (GTK_CONTAINER (xf_type_notebook), xft_simplexf_page); + + xf_simple_frame = gtk_frame_new (NULL); + gtk_widget_show (xf_simple_frame); + gtk_box_pack_start (GTK_BOX (xft_simplexf_page), xf_simple_frame, FALSE, FALSE, 0); + + xf_simple_table = gtk_table_new (1, 2, FALSE); + gtk_widget_show (xf_simple_table); + gtk_container_add (GTK_CONTAINER (xf_simple_frame), xf_simple_table); + gtk_container_set_border_width (GTK_CONTAINER (xf_simple_table), 5); + gtk_table_set_row_spacings (GTK_TABLE (xf_simple_table), 2); + gtk_table_set_col_spacings (GTK_TABLE (xf_simple_table), 5); + + simple_length_hbox = gtk_hbox_new (FALSE, 0); + gtk_widget_show (simple_length_hbox); + gtk_table_attach (GTK_TABLE (xf_simple_table), simple_length_hbox, 0, 1, 0, 1, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); + + simple_length_label = gtk_label_new ("Length (ms):"); + gtk_widget_show (simple_length_label); + gtk_box_pack_start (GTK_BOX (simple_length_hbox), simple_length_label, FALSE, FALSE, 0); + + simple_length_spin_adj = gtk_adjustment_new (1500, 0, 60000, 100, 1000, 10); + simple_length_spin = gtk_spin_button_new (GTK_ADJUSTMENT (simple_length_spin_adj), 0, 0); + gtk_widget_show (simple_length_spin); + gtk_table_attach (GTK_TABLE (xf_simple_table), simple_length_spin, 1, 2, 0, 1, + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + gtk_tooltips_set_tip (tooltips, simple_length_spin, "Specify the length of the crosssfade.\nDefault: depends on songchange type", NULL); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (simple_length_spin), TRUE); + + label15 = gtk_label_new ("Crossfade"); + gtk_widget_show (label15); + gtk_frame_set_label_widget (GTK_FRAME (xf_simple_frame), label15); + + xft_simplexf_label = gtk_label_new ("Simple XF"); + gtk_widget_show (xft_simplexf_label); + gtk_notebook_set_tab_label (GTK_NOTEBOOK (xf_type_notebook), gtk_notebook_get_nth_page (GTK_NOTEBOOK (xf_type_notebook), 4), xft_simplexf_label); + gtk_label_set_justify (GTK_LABEL (xft_simplexf_label), GTK_JUSTIFY_CENTER); + + xft_advancedxf_page = gtk_vbox_new (FALSE, 5); + gtk_widget_show (xft_advancedxf_page); + gtk_container_add (GTK_CONTAINER (xf_type_notebook), xft_advancedxf_page); + + xf_fadeout_frame = gtk_frame_new (NULL); + gtk_widget_show (xf_fadeout_frame); + gtk_box_pack_start (GTK_BOX (xft_advancedxf_page), xf_fadeout_frame, FALSE, FALSE, 0); + + xf_fadeout_table = gtk_table_new (3, 2, FALSE); + gtk_widget_show (xf_fadeout_table); + gtk_container_add (GTK_CONTAINER (xf_fadeout_frame), xf_fadeout_table); + gtk_container_set_border_width (GTK_CONTAINER (xf_fadeout_table), 5); + gtk_table_set_row_spacings (GTK_TABLE (xf_fadeout_table), 2); + gtk_table_set_col_spacings (GTK_TABLE (xf_fadeout_table), 5); + + fadeout_length_hbox = gtk_hbox_new (FALSE, 0); + gtk_widget_show (fadeout_length_hbox); + gtk_table_attach (GTK_TABLE (xf_fadeout_table), fadeout_length_hbox, 0, 1, 1, 2, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); + + fadeout_length_label = gtk_label_new ("Length (ms):"); + gtk_widget_show (fadeout_length_label); + gtk_box_pack_start (GTK_BOX (fadeout_length_hbox), fadeout_length_label, FALSE, FALSE, 0); + + fadeout_length_spin_adj = gtk_adjustment_new (1000, 0, 60000, 100, 1000, 10); + fadeout_length_spin = gtk_spin_button_new (GTK_ADJUSTMENT (fadeout_length_spin_adj), 0, 0); + gtk_widget_show (fadeout_length_spin); + gtk_table_attach (GTK_TABLE (xf_fadeout_table), fadeout_length_spin, 1, 2, 1, 2, + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + gtk_tooltips_set_tip (tooltips, fadeout_length_spin, "Set the duration for the fadeout of the previous song.", NULL); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (fadeout_length_spin), TRUE); + + fadeout_volume_hbox = gtk_hbox_new (FALSE, 0); + gtk_widget_show (fadeout_volume_hbox); + gtk_table_attach (GTK_TABLE (xf_fadeout_table), fadeout_volume_hbox, 0, 1, 2, 3, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); + + fadeout_volume_label = gtk_label_new ("End volume (%):"); + gtk_widget_show (fadeout_volume_label); + gtk_box_pack_start (GTK_BOX (fadeout_volume_hbox), fadeout_volume_label, FALSE, FALSE, 0); + + fadeout_volume_spin_adj = gtk_adjustment_new (0, 0, 100, 1, 10, 10); + fadeout_volume_spin = gtk_spin_button_new (GTK_ADJUSTMENT (fadeout_volume_spin_adj), 0, 0); + gtk_widget_show (fadeout_volume_spin); + gtk_table_attach (GTK_TABLE (xf_fadeout_table), fadeout_volume_spin, 1, 2, 2, 3, + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + gtk_tooltips_set_tip (tooltips, fadeout_volume_spin, "Set the end volume. XMMS-crossfade will fade from 100% to this volume during the time specified above.\nDefault: 0", NULL); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (fadeout_volume_spin), TRUE); + + fadeout_options_hbox = gtk_hbox_new (FALSE, 5); + gtk_widget_show (fadeout_options_hbox); + gtk_table_attach (GTK_TABLE (xf_fadeout_table), fadeout_options_hbox, 1, 2, 0, 1, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); + + fadeout_enable_check = gtk_check_button_new_with_mnemonic ("Enable"); + gtk_widget_show (fadeout_enable_check); + gtk_box_pack_start (GTK_BOX (fadeout_options_hbox), fadeout_enable_check, FALSE, FALSE, 0); + + label16 = gtk_label_new ("Fade out"); + gtk_widget_show (label16); + gtk_frame_set_label_widget (GTK_FRAME (xf_fadeout_frame), label16); + + xf_offset_frame = gtk_frame_new (NULL); + gtk_widget_show (xf_offset_frame); + gtk_box_pack_start (GTK_BOX (xft_advancedxf_page), xf_offset_frame, FALSE, FALSE, 0); + + xf_offset_table = gtk_table_new (4, 1, FALSE); + gtk_widget_show (xf_offset_table); + gtk_container_add (GTK_CONTAINER (xf_offset_frame), xf_offset_table); + gtk_container_set_border_width (GTK_CONTAINER (xf_offset_table), 5); + gtk_table_set_row_spacings (GTK_TABLE (xf_offset_table), 2); + gtk_table_set_col_spacings (GTK_TABLE (xf_offset_table), 5); + + xfofs_custom_hbox = gtk_hbox_new (FALSE, 5); + gtk_widget_show (xfofs_custom_hbox); + gtk_table_attach (GTK_TABLE (xf_offset_table), xfofs_custom_hbox, 0, 1, 3, 4, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); + + xfofs_custom_radiobutton = gtk_radio_button_new_with_mnemonic (NULL, "Custom (ms):"); + gtk_widget_show (xfofs_custom_radiobutton); + gtk_box_pack_start (GTK_BOX (xfofs_custom_hbox), xfofs_custom_radiobutton, FALSE, FALSE, 0); + gtk_tooltips_set_tip (tooltips, xfofs_custom_radiobutton, "Set a custom offset.", NULL); + gtk_radio_button_set_group (GTK_RADIO_BUTTON (xfofs_custom_radiobutton), xfofs_custom_radiobutton_group); + xfofs_custom_radiobutton_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (xfofs_custom_radiobutton)); + + xfofs_custom_spin_adj = gtk_adjustment_new (-2000, -60000, 60000, 100, 1000, 10); + xfofs_custom_spin = gtk_spin_button_new (GTK_ADJUSTMENT (xfofs_custom_spin_adj), 0, 0); + gtk_widget_show (xfofs_custom_spin); + gtk_box_pack_start (GTK_BOX (xfofs_custom_hbox), xfofs_custom_spin, TRUE, TRUE, 0); + gtk_tooltips_set_tip (tooltips, xfofs_custom_spin, "Set how much the end of the previous and the beginning of the next song should overlap.\n* Negative values indicate that the next song should start before the previous has reached the end.\n* A value of 0 means that the songs are concatenated seamlessly.\n* Positive values will yield insert silence inbetween..", NULL); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (xfofs_custom_spin), TRUE); + + xfofs_none_radiobutton = gtk_radio_button_new_with_mnemonic (NULL, "None (0 ms)"); + gtk_widget_show (xfofs_none_radiobutton); + gtk_table_attach (GTK_TABLE (xf_offset_table), xfofs_none_radiobutton, 0, 1, 0, 1, + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + gtk_tooltips_set_tip (tooltips, xfofs_none_radiobutton, "Don't overlap the two songs. The next song will start immediatelly after the previous has ended.", NULL); + gtk_radio_button_set_group (GTK_RADIO_BUTTON (xfofs_none_radiobutton), xfofs_custom_radiobutton_group); + xfofs_custom_radiobutton_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (xfofs_none_radiobutton)); + + xfofs_lockout_radiobutton = gtk_radio_button_new_with_mnemonic (NULL, "Lock to fadeout length"); + gtk_widget_show (xfofs_lockout_radiobutton); + gtk_table_attach (GTK_TABLE (xf_offset_table), xfofs_lockout_radiobutton, 0, 1, 1, 2, + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + gtk_tooltips_set_tip (tooltips, xfofs_lockout_radiobutton, "Overlap by the fadeout duration specified above.", NULL); + gtk_radio_button_set_group (GTK_RADIO_BUTTON (xfofs_lockout_radiobutton), xfofs_custom_radiobutton_group); + xfofs_custom_radiobutton_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (xfofs_lockout_radiobutton)); + + xfofs_lockin_radiobutton = gtk_radio_button_new_with_mnemonic (NULL, "Lock to fadein length"); + gtk_widget_show (xfofs_lockin_radiobutton); + gtk_table_attach (GTK_TABLE (xf_offset_table), xfofs_lockin_radiobutton, 0, 1, 2, 3, + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + gtk_tooltips_set_tip (tooltips, xfofs_lockin_radiobutton, "Overlap by the fadein duration specified below..", NULL); + gtk_radio_button_set_group (GTK_RADIO_BUTTON (xfofs_lockin_radiobutton), xfofs_custom_radiobutton_group); + xfofs_custom_radiobutton_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (xfofs_lockin_radiobutton)); + + label17 = gtk_label_new ("Offset"); + gtk_widget_show (label17); + gtk_frame_set_label_widget (GTK_FRAME (xf_offset_frame), label17); + + xf_fadein_frame = gtk_frame_new (NULL); + gtk_widget_show (xf_fadein_frame); + gtk_box_pack_start (GTK_BOX (xft_advancedxf_page), xf_fadein_frame, FALSE, FALSE, 0); + + xf_fadein_table = gtk_table_new (3, 2, FALSE); + gtk_widget_show (xf_fadein_table); + gtk_container_add (GTK_CONTAINER (xf_fadein_frame), xf_fadein_table); + gtk_container_set_border_width (GTK_CONTAINER (xf_fadein_table), 5); + gtk_table_set_row_spacings (GTK_TABLE (xf_fadein_table), 2); + gtk_table_set_col_spacings (GTK_TABLE (xf_fadein_table), 5); + + fadein_length_hbox = gtk_hbox_new (FALSE, 0); + gtk_widget_show (fadein_length_hbox); + gtk_table_attach (GTK_TABLE (xf_fadein_table), fadein_length_hbox, 0, 1, 1, 2, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); + + fadein_length_label = gtk_label_new ("Length (ms):"); + gtk_widget_show (fadein_length_label); + gtk_box_pack_start (GTK_BOX (fadein_length_hbox), fadein_length_label, FALSE, FALSE, 0); + + fadein_volume_hbox = gtk_hbox_new (FALSE, 0); + gtk_widget_show (fadein_volume_hbox); + gtk_table_attach (GTK_TABLE (xf_fadein_table), fadein_volume_hbox, 0, 1, 2, 3, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); + + fadein_volume_label = gtk_label_new ("Start volume (%):"); + gtk_widget_show (fadein_volume_label); + gtk_box_pack_start (GTK_BOX (fadein_volume_hbox), fadein_volume_label, FALSE, FALSE, 0); + + fadein_length_spin_adj = gtk_adjustment_new (1000, 0, 60000, 100, 1000, 10); + fadein_length_spin = gtk_spin_button_new (GTK_ADJUSTMENT (fadein_length_spin_adj), 0, 0); + gtk_widget_show (fadein_length_spin); + gtk_table_attach (GTK_TABLE (xf_fadein_table), fadein_length_spin, 1, 2, 1, 2, + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + gtk_tooltips_set_tip (tooltips, fadein_length_spin, "Set the duration for the fadein of the next song.", NULL); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (fadein_length_spin), TRUE); + + fadein_enable_check = gtk_check_button_new_with_mnemonic (" Enable"); + gtk_widget_show (fadein_enable_check); + gtk_table_attach (GTK_TABLE (xf_fadein_table), fadein_enable_check, 1, 2, 0, 1, + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + + fadein_lock_check = gtk_check_button_new_with_mnemonic ("Lock to Fade-out"); + gtk_widget_show (fadein_lock_check); + gtk_table_attach (GTK_TABLE (xf_fadein_table), fadein_lock_check, 0, 1, 0, 1, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + gtk_tooltips_set_tip (tooltips, fadein_lock_check, "Use the same settings as fade-out.", NULL); + + fadein_volume_spin_adj = gtk_adjustment_new (0, 0, 100, 1, 10, 10); + fadein_volume_spin = gtk_spin_button_new (GTK_ADJUSTMENT (fadein_volume_spin_adj), 0, 0); + gtk_widget_show (fadein_volume_spin); + gtk_table_attach (GTK_TABLE (xf_fadein_table), fadein_volume_spin, 1, 2, 2, 3, + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + gtk_tooltips_set_tip (tooltips, fadein_volume_spin, "Set the start volume. XMMS-crossfade will fade from this volume to 100% during the time specified above.\nDefault: 0", NULL); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (fadein_volume_spin), TRUE); + + label18 = gtk_label_new ("Fade in"); + gtk_widget_show (label18); + gtk_frame_set_label_widget (GTK_FRAME (xf_fadein_frame), label18); + + xft_advancedxf_label = gtk_label_new ("Advanced XF"); + gtk_widget_show (xft_advancedxf_label); + gtk_notebook_set_tab_label (GTK_NOTEBOOK (xf_type_notebook), gtk_notebook_get_nth_page (GTK_NOTEBOOK (xf_type_notebook), 5), xft_advancedxf_label); + gtk_label_set_justify (GTK_LABEL (xft_advancedxf_label), GTK_JUSTIFY_CENTER); + + xft_fadein_page = gtk_vbox_new (FALSE, 0); + gtk_widget_show (xft_fadein_page); + gtk_container_add (GTK_CONTAINER (xf_type_notebook), xft_fadein_page); + + xftfi_fadein_frame = gtk_frame_new (NULL); + gtk_widget_show (xftfi_fadein_frame); + gtk_box_pack_start (GTK_BOX (xft_fadein_page), xftfi_fadein_frame, FALSE, FALSE, 0); + + xftfi_fadein_table = gtk_table_new (2, 2, FALSE); + gtk_widget_show (xftfi_fadein_table); + gtk_container_add (GTK_CONTAINER (xftfi_fadein_frame), xftfi_fadein_table); + gtk_container_set_border_width (GTK_CONTAINER (xftfi_fadein_table), 5); + gtk_table_set_row_spacings (GTK_TABLE (xftfi_fadein_table), 2); + gtk_table_set_col_spacings (GTK_TABLE (xftfi_fadein_table), 5); + + xftfi_length_hbox = gtk_hbox_new (FALSE, 0); + gtk_widget_show (xftfi_length_hbox); + gtk_table_attach (GTK_TABLE (xftfi_fadein_table), xftfi_length_hbox, 0, 1, 0, 1, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); + + xftfi_length_label = gtk_label_new ("Length (ms):"); + gtk_widget_show (xftfi_length_label); + gtk_box_pack_start (GTK_BOX (xftfi_length_hbox), xftfi_length_label, FALSE, FALSE, 0); + + xftfi_volume_hbox = gtk_hbox_new (FALSE, 0); + gtk_widget_show (xftfi_volume_hbox); + gtk_table_attach (GTK_TABLE (xftfi_fadein_table), xftfi_volume_hbox, 0, 1, 1, 2, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); + + xftfi_volume_label = gtk_label_new ("Start volume (%):"); + gtk_widget_show (xftfi_volume_label); + gtk_box_pack_start (GTK_BOX (xftfi_volume_hbox), xftfi_volume_label, FALSE, FALSE, 0); + + xftfi_length_spin_adj = gtk_adjustment_new (1000, 0, 60000, 10, 100, 10); + xftfi_length_spin = gtk_spin_button_new (GTK_ADJUSTMENT (xftfi_length_spin_adj), 0, 0); + gtk_widget_show (xftfi_length_spin); + gtk_table_attach (GTK_TABLE (xftfi_fadein_table), xftfi_length_spin, 1, 2, 0, 1, + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + gtk_tooltips_set_tip (tooltips, xftfi_length_spin, "Set the duration for the fadein when starting playback.", NULL); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (xftfi_length_spin), TRUE); + + xftfi_volume_spin_adj = gtk_adjustment_new (0, 0, 100, 1, 10, 10); + xftfi_volume_spin = gtk_spin_button_new (GTK_ADJUSTMENT (xftfi_volume_spin_adj), 0, 0); + gtk_widget_show (xftfi_volume_spin); + gtk_table_attach (GTK_TABLE (xftfi_fadein_table), xftfi_volume_spin, 1, 2, 1, 2, + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + gtk_tooltips_set_tip (tooltips, xftfi_volume_spin, "Set the start volume. XMMS-crossfade will fade from this volume to 100% during the time specified above.\nDefault: 0", NULL); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (xftfi_volume_spin), TRUE); + + label19 = gtk_label_new ("Fade in"); + gtk_widget_show (label19); + gtk_frame_set_label_widget (GTK_FRAME (xftfi_fadein_frame), label19); + + xft_fadein_label = gtk_label_new ("Fade in"); + gtk_widget_show (xft_fadein_label); + gtk_notebook_set_tab_label (GTK_NOTEBOOK (xf_type_notebook), gtk_notebook_get_nth_page (GTK_NOTEBOOK (xf_type_notebook), 6), xft_fadein_label); + gtk_label_set_justify (GTK_LABEL (xft_fadein_label), GTK_JUSTIFY_CENTER); + + xft_fadeout_page = gtk_vbox_new (FALSE, 5); + gtk_widget_show (xft_fadeout_page); + gtk_container_add (GTK_CONTAINER (xf_type_notebook), xft_fadeout_page); + + xftfo_fadeout_frame = gtk_frame_new (NULL); + gtk_widget_show (xftfo_fadeout_frame); + gtk_box_pack_start (GTK_BOX (xft_fadeout_page), xftfo_fadeout_frame, FALSE, FALSE, 0); + + xftfo_fadeout_table = gtk_table_new (2, 2, FALSE); + gtk_widget_show (xftfo_fadeout_table); + gtk_container_add (GTK_CONTAINER (xftfo_fadeout_frame), xftfo_fadeout_table); + gtk_container_set_border_width (GTK_CONTAINER (xftfo_fadeout_table), 5); + gtk_table_set_row_spacings (GTK_TABLE (xftfo_fadeout_table), 2); + gtk_table_set_col_spacings (GTK_TABLE (xftfo_fadeout_table), 5); + + xftfo_length_hbox = gtk_hbox_new (FALSE, 0); + gtk_widget_show (xftfo_length_hbox); + gtk_table_attach (GTK_TABLE (xftfo_fadeout_table), xftfo_length_hbox, 0, 1, 0, 1, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); + + xftfo_length_label = gtk_label_new ("Length (ms):"); + gtk_widget_show (xftfo_length_label); + gtk_box_pack_start (GTK_BOX (xftfo_length_hbox), xftfo_length_label, FALSE, FALSE, 0); + + xftfo_length_spin_adj = gtk_adjustment_new (500, 0, 60000, 10, 100, 10); + xftfo_length_spin = gtk_spin_button_new (GTK_ADJUSTMENT (xftfo_length_spin_adj), 0, 0); + gtk_widget_show (xftfo_length_spin); + gtk_table_attach (GTK_TABLE (xftfo_fadeout_table), xftfo_length_spin, 1, 2, 0, 1, + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + gtk_tooltips_set_tip (tooltips, xftfo_length_spin, "Set the duration for the fadeout of the last song.", NULL); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (xftfo_length_spin), TRUE); + + xftfo_volume_hbox = gtk_hbox_new (FALSE, 0); + gtk_widget_show (xftfo_volume_hbox); + gtk_table_attach (GTK_TABLE (xftfo_fadeout_table), xftfo_volume_hbox, 0, 1, 1, 2, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); + + xftfo_volume_label = gtk_label_new ("End volume (%):"); + gtk_widget_show (xftfo_volume_label); + gtk_box_pack_start (GTK_BOX (xftfo_volume_hbox), xftfo_volume_label, FALSE, FALSE, 0); + + xftfo_volume_spin_adj = gtk_adjustment_new (0, 0, 100, 1, 10, 10); + xftfo_volume_spin = gtk_spin_button_new (GTK_ADJUSTMENT (xftfo_volume_spin_adj), 0, 0); + gtk_widget_show (xftfo_volume_spin); + gtk_table_attach (GTK_TABLE (xftfo_fadeout_table), xftfo_volume_spin, 1, 2, 1, 2, + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + gtk_tooltips_set_tip (tooltips, xftfo_volume_spin, "Set the end volume. XMMS-crossfade will fade from 100% to this volume during the time specified above.\nDefault: 0", NULL); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (xftfo_volume_spin), TRUE); + + label20 = gtk_label_new ("Fade out"); + gtk_widget_show (label20); + gtk_frame_set_label_widget (GTK_FRAME (xftfo_fadeout_frame), label20); + + xftfo_silence_frame = gtk_frame_new (NULL); + gtk_widget_show (xftfo_silence_frame); + gtk_box_pack_start (GTK_BOX (xft_fadeout_page), xftfo_silence_frame, FALSE, FALSE, 0); + + xftfo_silence_table = gtk_table_new (1, 2, FALSE); + gtk_widget_show (xftfo_silence_table); + gtk_container_add (GTK_CONTAINER (xftfo_silence_frame), xftfo_silence_table); + gtk_container_set_border_width (GTK_CONTAINER (xftfo_silence_table), 5); + gtk_table_set_row_spacings (GTK_TABLE (xftfo_silence_table), 2); + gtk_table_set_col_spacings (GTK_TABLE (xftfo_silence_table), 5); + + xftfo_silence_hbox = gtk_hbox_new (FALSE, 0); + gtk_widget_show (xftfo_silence_hbox); + gtk_table_attach (GTK_TABLE (xftfo_silence_table), xftfo_silence_hbox, 0, 1, 0, 1, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); + + xftfo_silence_label = gtk_label_new ("Length (ms):"); + gtk_widget_show (xftfo_silence_label); + gtk_box_pack_start (GTK_BOX (xftfo_silence_hbox), xftfo_silence_label, FALSE, FALSE, 0); + + xftfo_silence_spin_adj = gtk_adjustment_new (100, 0, 60000, 10, 100, 10); + xftfo_silence_spin = gtk_spin_button_new (GTK_ADJUSTMENT (xftfo_silence_spin_adj), 0, 0); + gtk_widget_show (xftfo_silence_spin); + gtk_table_attach (GTK_TABLE (xftfo_silence_table), xftfo_silence_spin, 1, 2, 0, 1, + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + gtk_tooltips_set_tip (tooltips, xftfo_silence_spin, "Set how much additional silence should be played after the end of the last song. This way, you can avoid the clicks some soundcards produce when being shut down during playback.\nDefault: 500", NULL); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (xftfo_silence_spin), TRUE); + + label21 = gtk_label_new ("Additional silence"); + gtk_widget_show (label21); + gtk_frame_set_label_widget (GTK_FRAME (xftfo_silence_frame), label21); + + xft_fadeout_label = gtk_label_new ("Fade out"); + gtk_widget_show (xft_fadeout_label); + gtk_notebook_set_tab_label (GTK_NOTEBOOK (xf_type_notebook), gtk_notebook_get_nth_page (GTK_NOTEBOOK (xf_type_notebook), 7), xft_fadeout_label); + gtk_label_set_justify (GTK_LABEL (xft_fadeout_label), GTK_JUSTIFY_CENTER); + + empty_notebook_page = gtk_vbox_new (FALSE, 0); + gtk_widget_show (empty_notebook_page); + gtk_container_add (GTK_CONTAINER (xf_type_notebook), empty_notebook_page); + + xft_pause_none_label = gtk_label_new ("None"); + gtk_widget_show (xft_pause_none_label); + gtk_notebook_set_tab_label (GTK_NOTEBOOK (xf_type_notebook), gtk_notebook_get_nth_page (GTK_NOTEBOOK (xf_type_notebook), 8), xft_pause_none_label); + gtk_label_set_justify (GTK_LABEL (xft_pause_none_label), GTK_JUSTIFY_CENTER); + + xft_pause_adv_page = gtk_vbox_new (FALSE, 5); + gtk_widget_show (xft_pause_adv_page); + gtk_container_add (GTK_CONTAINER (xf_type_notebook), xft_pause_adv_page); + + xft_fadeoutin_frame = gtk_frame_new (NULL); + gtk_widget_show (xft_fadeoutin_frame); + gtk_box_pack_start (GTK_BOX (xft_pause_adv_page), xft_fadeoutin_frame, FALSE, FALSE, 0); + + xft_fadeoutin_table = gtk_table_new (3, 2, FALSE); + gtk_widget_show (xft_fadeoutin_table); + gtk_container_add (GTK_CONTAINER (xft_fadeoutin_frame), xft_fadeoutin_table); + gtk_container_set_border_width (GTK_CONTAINER (xft_fadeoutin_table), 5); + gtk_table_set_row_spacings (GTK_TABLE (xft_fadeoutin_table), 2); + gtk_table_set_col_spacings (GTK_TABLE (xft_fadeoutin_table), 5); + + xftfoi_fadeout_spin_adj = gtk_adjustment_new (100, 0, 60000, 10, 100, 10); + xftfoi_fadeout_spin = gtk_spin_button_new (GTK_ADJUSTMENT (xftfoi_fadeout_spin_adj), 0, 0); + gtk_widget_show (xftfoi_fadeout_spin); + gtk_table_attach (GTK_TABLE (xft_fadeoutin_table), xftfoi_fadeout_spin, 1, 2, 0, 1, + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + gtk_tooltips_set_tip (tooltips, xftfoi_fadeout_spin, "Set the duration for the fadeout when pausing.\nDefault: 100\n", NULL); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (xftfoi_fadeout_spin), TRUE); + + xftfoi_silence_spin_adj = gtk_adjustment_new (100, 0, 60000, 10, 100, 10); + xftfoi_silence_spin = gtk_spin_button_new (GTK_ADJUSTMENT (xftfoi_silence_spin_adj), 0, 0); + gtk_widget_show (xftfoi_silence_spin); + gtk_table_attach (GTK_TABLE (xft_fadeoutin_table), xftfoi_silence_spin, 1, 2, 1, 2, + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + gtk_tooltips_set_tip (tooltips, xftfoi_silence_spin, "Set how much additional silence should be played after pausing. This way, you can avoid the clicks some soundcards produce when entering pause.\nDefault: 100", NULL); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (xftfoi_silence_spin), TRUE); + + xftfoi_fadein_spin_adj = gtk_adjustment_new (100, 0, 60000, 10, 100, 10); + xftfoi_fadein_spin = gtk_spin_button_new (GTK_ADJUSTMENT (xftfoi_fadein_spin_adj), 0, 0); + gtk_widget_show (xftfoi_fadein_spin); + gtk_table_attach (GTK_TABLE (xft_fadeoutin_table), xftfoi_fadein_spin, 1, 2, 2, 3, + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + gtk_tooltips_set_tip (tooltips, xftfoi_fadein_spin, "Set the duration for the fadein when unpausing.\nDefault: 100", NULL); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (xftfoi_fadein_spin), TRUE); + + xftfoi_fadein_hbox = gtk_hbox_new (FALSE, 0); + gtk_widget_show (xftfoi_fadein_hbox); + gtk_table_attach (GTK_TABLE (xft_fadeoutin_table), xftfoi_fadein_hbox, 0, 1, 0, 1, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + + xftfoi_fadein_label = gtk_label_new ("Fade out (ms):"); + gtk_widget_show (xftfoi_fadein_label); + gtk_box_pack_start (GTK_BOX (xftfoi_fadein_hbox), xftfoi_fadein_label, FALSE, FALSE, 0); + + xftfoi_silence_hbox = gtk_hbox_new (FALSE, 0); + gtk_widget_show (xftfoi_silence_hbox); + gtk_table_attach (GTK_TABLE (xft_fadeoutin_table), xftfoi_silence_hbox, 0, 1, 1, 2, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + + xftfoi_silence_label = gtk_label_new ("Silence (ms):"); + gtk_widget_show (xftfoi_silence_label); + gtk_box_pack_start (GTK_BOX (xftfoi_silence_hbox), xftfoi_silence_label, FALSE, FALSE, 0); + + xftfoi_fadeout_hbox = gtk_hbox_new (FALSE, 0); + gtk_widget_show (xftfoi_fadeout_hbox); + gtk_table_attach (GTK_TABLE (xft_fadeoutin_table), xftfoi_fadeout_hbox, 0, 1, 2, 3, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + + xftfoi_fadeout_label = gtk_label_new ("Fade in (ms):"); + gtk_widget_show (xftfoi_fadeout_label); + gtk_box_pack_start (GTK_BOX (xftfoi_fadeout_hbox), xftfoi_fadeout_label, FALSE, FALSE, 0); + + label22 = gtk_label_new ("Fade out / Fade in"); + gtk_widget_show (label22); + gtk_frame_set_label_widget (GTK_FRAME (xft_fadeoutin_frame), label22); + + xft_pause_adv_label = gtk_label_new ("Fade out / Fade in"); + gtk_widget_show (xft_pause_adv_label); + gtk_notebook_set_tab_label (GTK_NOTEBOOK (xf_type_notebook), gtk_notebook_get_nth_page (GTK_NOTEBOOK (xf_type_notebook), 9), xft_pause_adv_label); + gtk_label_set_justify (GTK_LABEL (xft_pause_adv_label), GTK_JUSTIFY_CENTER); + + config_crossfade_label = gtk_label_new ("Crossfader"); + gtk_widget_show (config_crossfade_label); + gtk_notebook_set_tab_label (GTK_NOTEBOOK (config_notebook), gtk_notebook_get_nth_page (GTK_NOTEBOOK (config_notebook), 2), config_crossfade_label); + gtk_label_set_justify (GTK_LABEL (config_crossfade_label), GTK_JUSTIFY_CENTER); + + config_gapkiller_page = gtk_vbox_new (FALSE, 5); + gtk_widget_show (config_gapkiller_page); + gtk_container_add (GTK_CONTAINER (config_notebook), config_gapkiller_page); + gtk_container_set_border_width (GTK_CONTAINER (config_gapkiller_page), 5); + + gap_leading_frame = gtk_frame_new (NULL); + gtk_widget_show (gap_leading_frame); + gtk_box_pack_start (GTK_BOX (config_gapkiller_page), gap_leading_frame, FALSE, TRUE, 0); + + gap_leading_table = gtk_table_new (3, 2, FALSE); + gtk_widget_show (gap_leading_table); + gtk_container_add (GTK_CONTAINER (gap_leading_frame), gap_leading_table); + gtk_container_set_border_width (GTK_CONTAINER (gap_leading_table), 5); + gtk_table_set_row_spacings (GTK_TABLE (gap_leading_table), 2); + gtk_table_set_col_spacings (GTK_TABLE (gap_leading_table), 5); + + lgap_length_spin_adj = gtk_adjustment_new (500, 0, 60000, 10, 100, 10); + lgap_length_spin = gtk_spin_button_new (GTK_ADJUSTMENT (lgap_length_spin_adj), 0, 0); + gtk_widget_show (lgap_length_spin); + gtk_table_attach (GTK_TABLE (gap_leading_table), lgap_length_spin, 1, 2, 1, 2, + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + gtk_tooltips_set_tip (tooltips, lgap_length_spin, "Set the maximum length for gaps at the beginning of a stream.\nDefault: 500", NULL); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (lgap_length_spin), TRUE); + + lgap_level_spin_adj = gtk_adjustment_new (512, 0, 32767, 16, 256, 10); + lgap_level_spin = gtk_spin_button_new (GTK_ADJUSTMENT (lgap_level_spin_adj), 0, 0); + gtk_widget_show (lgap_level_spin); + gtk_table_attach (GTK_TABLE (gap_leading_table), lgap_level_spin, 1, 2, 2, 3, + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + gtk_tooltips_set_tip (tooltips, lgap_level_spin, "Set the maximum volume for gaps at the beginning of a stream. All samples below this value are considered as silent.\nDefault: 512", NULL); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (lgap_level_spin), TRUE); + + lgap_length_hbox = gtk_hbox_new (FALSE, 0); + gtk_widget_show (lgap_length_hbox); + gtk_table_attach (GTK_TABLE (gap_leading_table), lgap_length_hbox, 0, 1, 1, 2, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (GTK_FILL), 0, 0); + + lgap_length_label = gtk_label_new ("Max. length (ms):"); + gtk_widget_show (lgap_length_label); + gtk_box_pack_start (GTK_BOX (lgap_length_hbox), lgap_length_label, FALSE, FALSE, 0); + gtk_label_set_justify (GTK_LABEL (lgap_length_label), GTK_JUSTIFY_CENTER); + + lgap_level_hbox = gtk_hbox_new (FALSE, 0); + gtk_widget_show (lgap_level_hbox); + gtk_table_attach (GTK_TABLE (gap_leading_table), lgap_level_hbox, 0, 1, 2, 3, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (GTK_FILL), 0, 0); + + lgap_level_label = gtk_label_new ("Max. level (16bit sample):"); + gtk_widget_show (lgap_level_label); + gtk_box_pack_start (GTK_BOX (lgap_level_hbox), lgap_level_label, FALSE, FALSE, 0); + gtk_label_set_justify (GTK_LABEL (lgap_level_label), GTK_JUSTIFY_CENTER); + + lgap_enable_check = gtk_check_button_new_with_mnemonic ("Enable"); + gtk_widget_show (lgap_enable_check); + gtk_table_attach (GTK_TABLE (gap_leading_table), lgap_enable_check, 1, 2, 0, 1, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + + label23 = gtk_label_new ("Leading gap killer"); + gtk_widget_show (label23); + gtk_frame_set_label_widget (GTK_FRAME (gap_leading_frame), label23); + + gap_trailing_frame = gtk_frame_new (NULL); + gtk_widget_show (gap_trailing_frame); + gtk_box_pack_start (GTK_BOX (config_gapkiller_page), gap_trailing_frame, FALSE, TRUE, 0); + + gap_trailing_table = gtk_table_new (3, 2, FALSE); + gtk_widget_show (gap_trailing_table); + gtk_container_add (GTK_CONTAINER (gap_trailing_frame), gap_trailing_table); + gtk_container_set_border_width (GTK_CONTAINER (gap_trailing_table), 5); + gtk_table_set_row_spacings (GTK_TABLE (gap_trailing_table), 2); + gtk_table_set_col_spacings (GTK_TABLE (gap_trailing_table), 5); + + tgap_length_hbox = gtk_hbox_new (FALSE, 0); + gtk_widget_show (tgap_length_hbox); + gtk_table_attach (GTK_TABLE (gap_trailing_table), tgap_length_hbox, 0, 1, 1, 2, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); + + tgap_length_label = gtk_label_new ("Max. length (ms):"); + gtk_widget_show (tgap_length_label); + gtk_box_pack_start (GTK_BOX (tgap_length_hbox), tgap_length_label, FALSE, FALSE, 0); + gtk_label_set_justify (GTK_LABEL (tgap_length_label), GTK_JUSTIFY_CENTER); + + tgap_level_hbox = gtk_hbox_new (FALSE, 0); + gtk_widget_show (tgap_level_hbox); + gtk_table_attach (GTK_TABLE (gap_trailing_table), tgap_level_hbox, 0, 1, 2, 3, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); + + tgap_level_label = gtk_label_new ("Max. level (16bit sample):"); + gtk_widget_show (tgap_level_label); + gtk_box_pack_start (GTK_BOX (tgap_level_hbox), tgap_level_label, FALSE, FALSE, 0); + gtk_label_set_justify (GTK_LABEL (tgap_level_label), GTK_JUSTIFY_CENTER); + + tgap_length_spin_adj = gtk_adjustment_new (500, 0, 60000, 10, 100, 10); + tgap_length_spin = gtk_spin_button_new (GTK_ADJUSTMENT (tgap_length_spin_adj), 0, 0); + gtk_widget_show (tgap_length_spin); + gtk_table_attach (GTK_TABLE (gap_trailing_table), tgap_length_spin, 1, 2, 1, 2, + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + gtk_tooltips_set_tip (tooltips, tgap_length_spin, "Set the maximum length for gaps at the end of a stream.\nDefault: 500", NULL); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (tgap_length_spin), TRUE); + + tgap_level_spin_adj = gtk_adjustment_new (512, 0, 32767, 1, 16, 10); + tgap_level_spin = gtk_spin_button_new (GTK_ADJUSTMENT (tgap_level_spin_adj), 0, 0); + gtk_widget_show (tgap_level_spin); + gtk_table_attach (GTK_TABLE (gap_trailing_table), tgap_level_spin, 1, 2, 2, 3, + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + gtk_tooltips_set_tip (tooltips, tgap_level_spin, "Set the maximum volume for gaps at the end of a stream. All samples below this value are considered as silent.\nDefault: 512", NULL); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (tgap_level_spin), TRUE); + + tgap_lock_check = gtk_check_button_new_with_mnemonic ("Lock to Leading"); + gtk_widget_show (tgap_lock_check); + gtk_table_attach (GTK_TABLE (gap_trailing_table), tgap_lock_check, 0, 1, 0, 1, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + gtk_tooltips_set_tip (tooltips, tgap_lock_check, "Use the same settings as above.", NULL); + + tgap_enable_check = gtk_check_button_new_with_mnemonic ("Enable"); + gtk_widget_show (tgap_enable_check); + gtk_table_attach (GTK_TABLE (gap_trailing_table), tgap_enable_check, 1, 2, 0, 1, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + + label24 = gtk_label_new ("Trailing gap killer"); + gtk_widget_show (label24); + gtk_frame_set_label_widget (GTK_FRAME (gap_trailing_frame), label24); + + gap_advanced_frame = gtk_frame_new (NULL); + gtk_widget_show (gap_advanced_frame); + gtk_box_pack_start (GTK_BOX (config_gapkiller_page), gap_advanced_frame, FALSE, FALSE, 0); + + gap_advanced_vbox = gtk_vbox_new (FALSE, 0); + gtk_widget_show (gap_advanced_vbox); + gtk_container_add (GTK_CONTAINER (gap_advanced_frame), gap_advanced_vbox); + gtk_container_set_border_width (GTK_CONTAINER (gap_advanced_vbox), 5); + + gadv_crossing_check = gtk_check_button_new_with_mnemonic ("Skip to next zero crossing"); + gtk_widget_show (gadv_crossing_check); + gtk_box_pack_start (GTK_BOX (gap_advanced_vbox), gadv_crossing_check, FALSE, FALSE, 0); + gtk_tooltips_set_tip (tooltips, gadv_crossing_check, "If enabled, XMMS-crossfade will take additional care to avoid clicks with pre-faded (gapless) tracks. XMMS-crossfade will cut off the end of the previous song (the beginning of the next song) only at a zero-crossing of the sample values.\nDefault: On", NULL); + + label25 = gtk_label_new ("Advanced"); + gtk_widget_show (label25); + gtk_frame_set_label_widget (GTK_FRAME (gap_advanced_frame), label25); + + config_gapkiller_label = gtk_label_new ("Gap Killer"); + gtk_widget_show (config_gapkiller_label); + gtk_notebook_set_tab_label (GTK_NOTEBOOK (config_notebook), gtk_notebook_get_nth_page (GTK_NOTEBOOK (config_notebook), 3), config_gapkiller_label); + gtk_label_set_justify (GTK_LABEL (config_gapkiller_label), GTK_JUSTIFY_CENTER); + + config_misc_page = gtk_vbox_new (FALSE, 5); + gtk_widget_show (config_misc_page); + gtk_container_add (GTK_CONTAINER (config_notebook), config_misc_page); + gtk_container_set_border_width (GTK_CONTAINER (config_misc_page), 5); + + misc_debug_frame = gtk_frame_new (NULL); + gtk_widget_show (misc_debug_frame); + gtk_box_pack_start (GTK_BOX (config_misc_page), misc_debug_frame, FALSE, FALSE, 0); + + misc_debug_vbox = gtk_vbox_new (FALSE, 2); + gtk_widget_show (misc_debug_vbox); + gtk_container_add (GTK_CONTAINER (misc_debug_frame), misc_debug_vbox); + gtk_container_set_border_width (GTK_CONTAINER (misc_debug_vbox), 5); + + debug_stderr_check = gtk_check_button_new_with_mnemonic ("Write debug output to "); + gtk_widget_show (debug_stderr_check); + gtk_box_pack_start (GTK_BOX (misc_debug_vbox), debug_stderr_check, FALSE, FALSE, 0); + gtk_tooltips_set_tip (tooltips, debug_stderr_check, "Monitors what is going on in XMMS-crossfade. If you think you found a bug in XMMS-crossfade, please enable this option and send me the output.\nNote that you should disable debug output if you start XMMS from within Netscape. Netscape will spam you with dialogs containing the debug output captured from .\nDefault: Off", NULL); + + debug_monitor_check = gtk_check_button_new_with_mnemonic ("Show Buffer Monitor"); + gtk_widget_show (debug_monitor_check); + gtk_box_pack_start (GTK_BOX (misc_debug_vbox), debug_monitor_check, FALSE, FALSE, 0); + gtk_tooltips_set_tip (tooltips, debug_monitor_check, "Enables the Buffer Monitor. This is a small window which shows how much data is in the buffers. The top display belongs to the mixing buffer, the bottom shows how much data is being buffered by the output plugin.\nDefault: Off", NULL); + + label26 = gtk_label_new ("Debug options"); + gtk_widget_show (label26); + gtk_frame_set_label_widget (GTK_FRAME (misc_debug_frame), label26); + + misc_mixopt_frame = gtk_frame_new (NULL); + gtk_widget_show (misc_mixopt_frame); + gtk_box_pack_start (GTK_BOX (config_misc_page), misc_mixopt_frame, FALSE, FALSE, 0); + + misc_mixopt_vbox = gtk_vbox_new (FALSE, 2); + gtk_widget_show (misc_mixopt_vbox); + gtk_container_add (GTK_CONTAINER (misc_mixopt_frame), misc_mixopt_vbox); + gtk_container_set_border_width (GTK_CONTAINER (misc_mixopt_vbox), 5); + + mixopt_enable_check = gtk_check_button_new_with_mnemonic ("Enable volume control"); + gtk_widget_show (mixopt_enable_check); + gtk_box_pack_start (GTK_BOX (misc_mixopt_vbox), mixopt_enable_check, FALSE, FALSE, 0); + gtk_tooltips_set_tip (tooltips, mixopt_enable_check, "Enables/disables XMMS volume and balance controls.\nDefault: On", NULL); + + mixopt_reverse_check = gtk_check_button_new_with_mnemonic ("Reverse balance"); + gtk_widget_show (mixopt_reverse_check); + gtk_box_pack_start (GTK_BOX (misc_mixopt_vbox), mixopt_reverse_check, FALSE, FALSE, 0); + gtk_tooltips_set_tip (tooltips, mixopt_reverse_check, "Reverses left and right with the balance control.\nDefault: Off", NULL); + + mixopt_software_check = gtk_check_button_new_with_mnemonic ("Software Mixer"); + gtk_widget_show (mixopt_software_check); + gtk_box_pack_start (GTK_BOX (misc_mixopt_vbox), mixopt_software_check, FALSE, FALSE, 0); + gtk_tooltips_set_tip (tooltips, mixopt_software_check, "Enable software mixer. Usefull for output plugins without mixer support.\nDefault: Off", NULL); + + label27 = gtk_label_new ("Volume control options"); + gtk_widget_show (label27); + gtk_frame_set_label_widget (GTK_FRAME (misc_mixopt_frame), label27); + + misc_other_frame = gtk_frame_new (NULL); + gtk_widget_show (misc_other_frame); + gtk_box_pack_start (GTK_BOX (config_misc_page), misc_other_frame, FALSE, TRUE, 0); + + misc_other_vbox = gtk_vbox_new (FALSE, 2); + gtk_widget_show (misc_other_vbox); + gtk_container_add (GTK_CONTAINER (misc_other_frame), misc_other_vbox); + gtk_container_set_border_width (GTK_CONTAINER (misc_other_vbox), 5); + + moth_songchange_hbox = gtk_hbox_new (FALSE, 5); + gtk_widget_show (moth_songchange_hbox); + gtk_box_pack_start (GTK_BOX (misc_other_vbox), moth_songchange_hbox, TRUE, TRUE, 0); + + moth_songchange_label = gtk_label_new ("Songchange timeout (ms):"); + gtk_widget_show (moth_songchange_label); + gtk_box_pack_start (GTK_BOX (moth_songchange_hbox), moth_songchange_label, FALSE, FALSE, 0); + gtk_widget_set_sensitive (moth_songchange_label, FALSE); + gtk_label_set_justify (GTK_LABEL (moth_songchange_label), GTK_JUSTIFY_CENTER); + + moth_songchange_spin_adj = gtk_adjustment_new (500, 10, 10000, 10, 100, 10); + moth_songchange_spin = gtk_spin_button_new (GTK_ADJUSTMENT (moth_songchange_spin_adj), 0, 0); + gtk_widget_show (moth_songchange_spin); + gtk_box_pack_start (GTK_BOX (moth_songchange_hbox), moth_songchange_spin, TRUE, TRUE, 0); + gtk_widget_set_sensitive (moth_songchange_spin, FALSE); + gtk_tooltips_set_tip (tooltips, moth_songchange_spin, "The songchange timeout is the maximum time XMMS-crossfade waits for the next song. If this timeout is exceeded, the output plugin/device is closed.\nDefault: 500", NULL); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (moth_songchange_spin), TRUE); + + moth_preload_hbox = gtk_hbox_new (FALSE, 5); + gtk_widget_show (moth_preload_hbox); + gtk_box_pack_start (GTK_BOX (misc_other_vbox), moth_preload_hbox, TRUE, TRUE, 0); + + moth_preload_label = gtk_label_new ("Mixing buffer preload (ms):"); + gtk_widget_show (moth_preload_label); + gtk_box_pack_start (GTK_BOX (moth_preload_hbox), moth_preload_label, FALSE, FALSE, 0); + gtk_label_set_justify (GTK_LABEL (moth_preload_label), GTK_JUSTIFY_CENTER); + + moth_preload_spin_adj = gtk_adjustment_new (0, 0, 60000, 10, 100, 10); + moth_preload_spin = gtk_spin_button_new (GTK_ADJUSTMENT (moth_preload_spin_adj), 0, 0); + gtk_widget_show (moth_preload_spin); + gtk_box_pack_start (GTK_BOX (moth_preload_hbox), moth_preload_spin, TRUE, TRUE, 0); + gtk_tooltips_set_tip (tooltips, moth_preload_spin, "Tells XMMS-crossfade how much data it should buffer before it starts writing to the output plugin/device. Usually, this value can be set to 0, because the output plugin does preloading on its own.\nDefault: 0", NULL); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (moth_preload_spin), TRUE); + + moth_noxf_hbox = gtk_hbox_new (FALSE, 5); + gtk_widget_show (moth_noxf_hbox); + gtk_box_pack_start (GTK_BOX (misc_other_vbox), moth_noxf_hbox, FALSE, FALSE, 0); + + moth_noxf_label = gtk_label_new ("Don't crossfade"); + gtk_widget_show (moth_noxf_label); + gtk_box_pack_start (GTK_BOX (moth_noxf_hbox), moth_noxf_label, FALSE, FALSE, 0); + gtk_label_set_justify (GTK_LABEL (moth_noxf_label), GTK_JUSTIFY_CENTER); + + noxf_album_check = gtk_check_button_new_with_mnemonic ("successive tracks"); + gtk_widget_show (noxf_album_check); + gtk_box_pack_start (GTK_BOX (moth_noxf_hbox), noxf_album_check, FALSE, FALSE, 0); + gtk_tooltips_set_tip (tooltips, noxf_album_check, "This option enables the automatic detection of pre-faded or gapless tracks, like the tracks on some compilations or on most live albums. If such tracks are detected, crossfading will be disabled and only the gapkiller (if enabled) will be used for the songchange.\nDefault: On", NULL); + + noxf_samefile_check = gtk_check_button_new_with_mnemonic ("same file"); + gtk_widget_show (noxf_samefile_check); + gtk_box_pack_start (GTK_BOX (moth_noxf_hbox), noxf_samefile_check, FALSE, FALSE, 0); + gtk_tooltips_set_tip (tooltips, noxf_samefile_check, "This option disables crossfading between the same file. This can happen if you have only one file in the playlist and 'repeat' turned on.\nDefault: Off", NULL); + + moth_httpworkaround_check = gtk_check_button_new_with_mnemonic ("Enable HTTP buffer underrun workaround"); + gtk_widget_show (moth_httpworkaround_check); + gtk_box_pack_start (GTK_BOX (misc_other_vbox), moth_httpworkaround_check, FALSE, FALSE, 0); + gtk_tooltips_set_tip (tooltips, moth_httpworkaround_check, "Enable this when you have problems playing internet HTTP audio streams. Unfortunatelly, it also breaks crossfading.\nDefault: Off", NULL); + + moth_opmaxused_hbox = gtk_hbox_new (FALSE, 5); + gtk_widget_show (moth_opmaxused_hbox); + gtk_box_pack_start (GTK_BOX (misc_other_vbox), moth_opmaxused_hbox, TRUE, TRUE, 0); + + moth_opmaxused_check = gtk_check_button_new_with_mnemonic ("Limit OP buffer usage (ms):"); + gtk_widget_show (moth_opmaxused_check); + gtk_box_pack_start (GTK_BOX (moth_opmaxused_hbox), moth_opmaxused_check, FALSE, FALSE, 0); + gtk_tooltips_set_tip (tooltips, moth_opmaxused_check, "With this option enabled, XMMS-crossfade will limit the amount of data being buffered by the output plugin. This way, you can decrease the latency between pressing STOP/NEXT/PREV and the new song actually being played. \nDefault: Off", NULL); + + moth_opmaxused_spin_adj = gtk_adjustment_new (500, 10, 10000, 10, 100, 10); + moth_opmaxused_spin = gtk_spin_button_new (GTK_ADJUSTMENT (moth_opmaxused_spin_adj), 0, 0); + gtk_widget_show (moth_opmaxused_spin); + gtk_box_pack_start (GTK_BOX (moth_opmaxused_hbox), moth_opmaxused_spin, TRUE, TRUE, 0); + gtk_tooltips_set_tip (tooltips, moth_opmaxused_spin, "Beware that setting this value too low also increases the chance of buffer underruns.\nDefault: 250", NULL); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (moth_opmaxused_spin), TRUE); + + moth_quantaudio_check = gtk_check_button_new_with_mnemonic ("Use Quantaudio timing comments"); + gtk_box_pack_start (GTK_BOX (misc_other_vbox), moth_quantaudio_check, FALSE, FALSE, 0); + gtk_tooltips_set_tip (tooltips, moth_quantaudio_check, "Enable this when you have problems playing internet HTTP audio streams. Unfortunatelly, it also breaks crossfading.\nDefault: Off", NULL); + + moth_outputkeepopened_check = gtk_check_button_new_with_mnemonic ("Keep output opened"); + gtk_widget_show (moth_outputkeepopened_check); + gtk_box_pack_start (GTK_BOX (misc_other_vbox), moth_outputkeepopened_check, FALSE, FALSE, 0); + gtk_tooltips_set_tip (tooltips, moth_outputkeepopened_check, "Keep the output device opened all the time, even if XMMS is stopped. This way, you can avoid clicks caused by the soundcard when the device is opened or closed\nDefault: Off", NULL); + + label28 = gtk_label_new ("Advanced options"); + gtk_widget_show (label28); + gtk_frame_set_label_widget (GTK_FRAME (misc_other_frame), label28); + + config_misc_label = gtk_label_new ("Advanced"); + gtk_widget_show (config_misc_label); + gtk_notebook_set_tab_label (GTK_NOTEBOOK (config_notebook), gtk_notebook_get_nth_page (GTK_NOTEBOOK (config_notebook), 4), config_misc_label); + gtk_label_set_justify (GTK_LABEL (config_misc_label), GTK_JUSTIFY_CENTER); + + config_presets_page = gtk_vbox_new (FALSE, 5); + gtk_container_add (GTK_CONTAINER (config_notebook), config_presets_page); + gtk_container_set_border_width (GTK_CONTAINER (config_presets_page), 5); + + presets_name_hbox = gtk_hbox_new (FALSE, 5); + gtk_widget_show (presets_name_hbox); + gtk_box_pack_start (GTK_BOX (config_presets_page), presets_name_hbox, FALSE, FALSE, 0); + + presets_name_entry = gtk_entry_new (); + gtk_widget_show (presets_name_entry); + gtk_box_pack_start (GTK_BOX (presets_name_hbox), presets_name_entry, TRUE, TRUE, 0); + + presets_delete_button = gtk_button_new_with_mnemonic ("Delete"); + gtk_widget_show (presets_delete_button); + gtk_box_pack_start (GTK_BOX (presets_name_hbox), presets_delete_button, FALSE, FALSE, 0); + + presets_new_button = gtk_button_new_with_mnemonic ("New"); + gtk_widget_show (presets_new_button); + gtk_box_pack_start (GTK_BOX (presets_name_hbox), presets_new_button, FALSE, FALSE, 0); + + presets_list_scrolledwindow = gtk_scrolled_window_new (NULL, NULL); + gtk_widget_show (presets_list_scrolledwindow); + gtk_box_pack_start (GTK_BOX (config_presets_page), presets_list_scrolledwindow, TRUE, TRUE, 0); + GTK_WIDGET_UNSET_FLAGS (presets_list_scrolledwindow, GTK_CAN_FOCUS); + gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (presets_list_scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); + gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (presets_list_scrolledwindow), GTK_SHADOW_IN); + + presets_list_list = gtk_tree_view_new (); + gtk_widget_show (presets_list_list); + gtk_container_add (GTK_CONTAINER (presets_list_scrolledwindow), presets_list_list); + + presets_list_bbox = gtk_hbutton_box_new (); + gtk_widget_show (presets_list_bbox); + gtk_box_pack_start (GTK_BOX (config_presets_page), presets_list_bbox, FALSE, FALSE, 0); + gtk_button_box_set_layout (GTK_BUTTON_BOX (presets_list_bbox), GTK_BUTTONBOX_END); + gtk_box_set_spacing (GTK_BOX (presets_list_bbox), 5); + + presets_load_button = gtk_button_new_with_mnemonic ("Load"); + gtk_widget_show (presets_load_button); + gtk_container_add (GTK_CONTAINER (presets_list_bbox), presets_load_button); + GTK_WIDGET_SET_FLAGS (presets_load_button, GTK_CAN_DEFAULT); + + presets_save_button = gtk_button_new_with_mnemonic ("Save"); + gtk_widget_show (presets_save_button); + gtk_container_add (GTK_CONTAINER (presets_list_bbox), presets_save_button); + GTK_WIDGET_SET_FLAGS (presets_save_button, GTK_CAN_DEFAULT); + + config_presets_label = gtk_label_new ("Presets"); + gtk_widget_show (config_presets_label); + gtk_notebook_set_tab_label (GTK_NOTEBOOK (config_notebook), gtk_notebook_get_nth_page (GTK_NOTEBOOK (config_notebook), 5), config_presets_label); + gtk_label_set_justify (GTK_LABEL (config_presets_label), GTK_JUSTIFY_CENTER); + + config_bbox = gtk_hbutton_box_new (); + gtk_widget_show (config_bbox); + gtk_box_pack_start (GTK_BOX (config_vbox), config_bbox, FALSE, TRUE, 0); + gtk_button_box_set_layout (GTK_BUTTON_BOX (config_bbox), GTK_BUTTONBOX_END); + gtk_box_set_spacing (GTK_BOX (config_bbox), 5); + + config_ok = gtk_button_new_with_mnemonic ("OK"); + gtk_widget_show (config_ok); + gtk_container_add (GTK_CONTAINER (config_bbox), config_ok); + GTK_WIDGET_SET_FLAGS (config_ok, GTK_CAN_DEFAULT); + + config_cancel = gtk_button_new_with_mnemonic ("Cancel"); + gtk_widget_show (config_cancel); + gtk_container_add (GTK_CONTAINER (config_bbox), config_cancel); + GTK_WIDGET_SET_FLAGS (config_cancel, GTK_CAN_DEFAULT); + + config_apply = gtk_button_new_with_mnemonic ("Apply"); + gtk_widget_show (config_apply); + gtk_container_add (GTK_CONTAINER (config_bbox), config_apply); + GTK_WIDGET_SET_FLAGS (config_apply, GTK_CAN_DEFAULT); + + g_signal_connect ((gpointer) op_configure_button, "clicked", + G_CALLBACK (on_output_plugin_configure_button_clicked), + NULL); + g_signal_connect ((gpointer) op_about_button, "clicked", + G_CALLBACK (on_output_plugin_about_button_clicked), + NULL); + g_signal_connect ((gpointer) op_throttle_check, "toggled", + G_CALLBACK (on_op_throttle_check_toggled), + NULL); + g_signal_connect ((gpointer) op_maxblock_check, "toggled", + G_CALLBACK (on_op_maxblock_check_toggled), + NULL); + g_signal_connect ((gpointer) op_maxblock_spin, "changed", + G_CALLBACK (on_op_maxblock_spin_changed), + NULL); + g_signal_connect ((gpointer) op_forcereopen_check, "toggled", + G_CALLBACK (on_op_forcereopen_check_toggled), + NULL); + g_signal_connect ((gpointer) ep_configure_button, "clicked", + G_CALLBACK (on_ep_configure_button_clicked), + NULL); + g_signal_connect ((gpointer) ep_about_button, "clicked", + G_CALLBACK (on_ep_about_button_clicked), + NULL); + g_signal_connect ((gpointer) ep_enable_check, "toggled", + G_CALLBACK (on_ep_enable_check_toggled), + NULL); + g_signal_connect ((gpointer) volnorm_enable_check, "toggled", + G_CALLBACK (on_volnorm_enable_check_toggled), + NULL); + g_signal_connect ((gpointer) xf_buffer_spin, "changed", + G_CALLBACK (on_xf_buffer_spin_changed), + NULL); + g_signal_connect ((gpointer) xf_autobuf_check, "toggled", + G_CALLBACK (on_xf_autobuf_check_toggled), + NULL); + g_signal_connect ((gpointer) xftfp_length_spin, "changed", + G_CALLBACK (on_xftfp_length_spin_changed), + NULL); + g_signal_connect ((gpointer) xftfp_enable_check, "toggled", + G_CALLBACK (on_xftfp_enable_check_toggled), + NULL); + g_signal_connect ((gpointer) xftffi_length_spin, "changed", + G_CALLBACK (on_xftffi_length_spin_changed), + NULL); + g_signal_connect ((gpointer) xftffi_enable_check, "toggled", + G_CALLBACK (on_xftffi_enable_check_toggled), + NULL); + g_signal_connect ((gpointer) xftffi_volume_spin, "changed", + G_CALLBACK (on_xftffi_volume_spin_changed), + NULL); + g_signal_connect ((gpointer) pause_length_spin, "changed", + G_CALLBACK (on_pause_length_spin_changed), + NULL); + g_signal_connect ((gpointer) simple_length_spin, "changed", + G_CALLBACK (on_simple_length_spin_changed), + NULL); + g_signal_connect ((gpointer) fadeout_length_spin, "changed", + G_CALLBACK (on_fadeout_length_spin_changed), + NULL); + g_signal_connect ((gpointer) fadeout_volume_spin, "changed", + G_CALLBACK (on_fadeout_volume_spin_changed), + NULL); + g_signal_connect ((gpointer) fadeout_enable_check, "toggled", + G_CALLBACK (on_fadeout_enable_check_toggled), + NULL); + g_signal_connect ((gpointer) xfofs_custom_radiobutton, "toggled", + G_CALLBACK (on_xfofs_custom_radiobutton_toggled), + NULL); + g_signal_connect ((gpointer) xfofs_custom_radiobutton, "clicked", + G_CALLBACK (on_xfofs_custom_radiobutton_clicked), + NULL); + g_signal_connect ((gpointer) xfofs_custom_spin, "changed", + G_CALLBACK (on_xfofs_custom_spin_changed), + NULL); + g_signal_connect ((gpointer) xfofs_none_radiobutton, "clicked", + G_CALLBACK (on_xfofs_none_radiobutton_clicked), + NULL); + g_signal_connect ((gpointer) xfofs_none_radiobutton, "toggled", + G_CALLBACK (on_xfofs_none_radiobutton_toggled), + NULL); + g_signal_connect ((gpointer) xfofs_lockout_radiobutton, "toggled", + G_CALLBACK (on_xfofs_lockout_radiobutton_toggled), + NULL); + g_signal_connect ((gpointer) xfofs_lockout_radiobutton, "clicked", + G_CALLBACK (on_xfofs_lockout_radiobutton_clicked), + NULL); + g_signal_connect ((gpointer) xfofs_lockin_radiobutton, "toggled", + G_CALLBACK (on_xfofs_lockin_radiobutton_toggled), + NULL); + g_signal_connect ((gpointer) xfofs_lockin_radiobutton, "clicked", + G_CALLBACK (on_xfofs_lockin_radiobutton_clicked), + NULL); + g_signal_connect ((gpointer) fadein_length_spin, "changed", + G_CALLBACK (on_fadein_length_spin_changed), + NULL); + g_signal_connect ((gpointer) fadein_enable_check, "toggled", + G_CALLBACK (on_fadein_enable_check_toggled), + NULL); + g_signal_connect ((gpointer) fadein_lock_check, "toggled", + G_CALLBACK (on_fadein_lock_check_toggled), + NULL); + g_signal_connect ((gpointer) fadein_volume_spin, "changed", + G_CALLBACK (on_fadein_volume_spin_changed), + NULL); + g_signal_connect ((gpointer) xftfi_length_spin, "changed", + G_CALLBACK (on_fadein_length_spin_changed), + NULL); + g_signal_connect ((gpointer) xftfi_volume_spin, "changed", + G_CALLBACK (on_fadein_volume_spin_changed), + NULL); + g_signal_connect ((gpointer) xftfo_length_spin, "changed", + G_CALLBACK (on_fadeout_length_spin_changed), + NULL); + g_signal_connect ((gpointer) xftfo_volume_spin, "changed", + G_CALLBACK (on_fadeout_volume_spin_changed), + NULL); + g_signal_connect ((gpointer) xftfo_silence_spin, "changed", + G_CALLBACK (on_xfofs_custom_spin_changed), + NULL); + g_signal_connect ((gpointer) xftfoi_fadeout_spin, "changed", + G_CALLBACK (on_fadeout_length_spin_changed), + NULL); + g_signal_connect ((gpointer) xftfoi_silence_spin, "changed", + G_CALLBACK (on_xfofs_custom_spin_changed), + NULL); + g_signal_connect ((gpointer) xftfoi_fadein_spin, "changed", + G_CALLBACK (on_fadein_length_spin_changed), + NULL); + g_signal_connect ((gpointer) lgap_length_spin, "changed", + G_CALLBACK (on_lgap_length_spin_changed), + NULL); + g_signal_connect ((gpointer) lgap_level_spin, "changed", + G_CALLBACK (on_lgap_level_spin_changed), + NULL); + g_signal_connect ((gpointer) lgap_enable_check, "toggled", + G_CALLBACK (on_lgap_enable_check_toggled), + NULL); + g_signal_connect ((gpointer) tgap_length_spin, "changed", + G_CALLBACK (on_tgap_length_spin_changed), + NULL); + g_signal_connect ((gpointer) tgap_level_spin, "changed", + G_CALLBACK (on_tgap_level_spin_changed), + NULL); + g_signal_connect ((gpointer) tgap_lock_check, "toggled", + G_CALLBACK (on_tgap_lock_check_toggled), + NULL); + g_signal_connect ((gpointer) tgap_enable_check, "toggled", + G_CALLBACK (on_tgap_enable_check_toggled), + NULL); + g_signal_connect ((gpointer) mixopt_enable_check, "toggled", + G_CALLBACK (on_config_mixopt_enable_check_toggled), + NULL); + g_signal_connect ((gpointer) moth_songchange_spin, "changed", + G_CALLBACK (on_moth_songchange_spin_changed), + NULL); + g_signal_connect ((gpointer) moth_opmaxused_check, "toggled", + G_CALLBACK (on_moth_opmaxused_check_toggled), + NULL); + g_signal_connect ((gpointer) presets_list_list, "click_column", + G_CALLBACK (on_presets_list_click_column), + NULL); + g_signal_connect ((gpointer) config_ok, "clicked", + G_CALLBACK (on_config_ok_clicked), + NULL); + g_signal_connect_swapped ((gpointer) config_cancel, "clicked", + G_CALLBACK (gtk_widget_destroy), + GTK_OBJECT (config_win)); + g_signal_connect ((gpointer) config_apply, "clicked", + G_CALLBACK (on_config_apply_clicked), + NULL); + + /* Store pointers to all widgets, for use by lookup_widget(). */ + GLADE_HOOKUP_OBJECT_NO_REF (config_win, config_win, "config_win"); + GLADE_HOOKUP_OBJECT (config_win, config_vbox, "config_vbox"); + GLADE_HOOKUP_OBJECT (config_win, config_notebook, "config_notebook"); + GLADE_HOOKUP_OBJECT (config_win, config_output_page, "config_output_page"); + GLADE_HOOKUP_OBJECT (config_win, output_options_hbox, "output_options_hbox"); + GLADE_HOOKUP_OBJECT (config_win, output_resampling_frame, "output_resampling_frame"); + GLADE_HOOKUP_OBJECT (config_win, output_resampling_table, "output_resampling_table"); + GLADE_HOOKUP_OBJECT (config_win, resampling_rate_hbox, "resampling_rate_hbox"); + GLADE_HOOKUP_OBJECT (config_win, resampling_rate_label, "resampling_rate_label"); + GLADE_HOOKUP_OBJECT (config_win, resampling_quality_hbox, "resampling_quality_hbox"); + GLADE_HOOKUP_OBJECT (config_win, resampling_quality_label, "resampling_quality_label"); + GLADE_HOOKUP_OBJECT (config_win, resampling_rate_optionmenu, "resampling_rate_optionmenu"); + GLADE_HOOKUP_OBJECT (config_win, resampling_quality_optionmenu, "resampling_quality_optionmenu"); + GLADE_HOOKUP_OBJECT (config_win, output_resampling_label, "output_resampling_label"); + GLADE_HOOKUP_OBJECT (config_win, output_notebook, "output_notebook"); + GLADE_HOOKUP_OBJECT (config_win, output_plugin_page, "output_plugin_page"); + GLADE_HOOKUP_OBJECT (config_win, op_plugin_frame, "op_plugin_frame"); + GLADE_HOOKUP_OBJECT (config_win, op_plugin_vbox, "op_plugin_vbox"); + GLADE_HOOKUP_OBJECT (config_win, op_plugin_optionmenu, "op_plugin_optionmenu"); + GLADE_HOOKUP_OBJECT (config_win, convertwidget5, "convertwidget5"); + GLADE_HOOKUP_OBJECT (config_win, convertwidget6, "convertwidget6"); + GLADE_HOOKUP_OBJECT (config_win, op_plugin_buttonbox, "op_plugin_buttonbox"); + GLADE_HOOKUP_OBJECT (config_win, op_configure_button, "op_configure_button"); + GLADE_HOOKUP_OBJECT (config_win, op_about_button, "op_about_button"); + GLADE_HOOKUP_OBJECT (config_win, label8, "label8"); + GLADE_HOOKUP_OBJECT (config_win, op_options_frame, "op_options_frame"); + GLADE_HOOKUP_OBJECT (config_win, op_options_vbox, "op_options_vbox"); + GLADE_HOOKUP_OBJECT (config_win, op_throttle_check, "op_throttle_check"); + GLADE_HOOKUP_OBJECT (config_win, op_maxblock_hbox, "op_maxblock_hbox"); + GLADE_HOOKUP_OBJECT (config_win, op_maxblock_check, "op_maxblock_check"); + GLADE_HOOKUP_OBJECT (config_win, op_maxblock_spin, "op_maxblock_spin"); + GLADE_HOOKUP_OBJECT (config_win, op_forcereopen_check, "op_forcereopen_check"); + GLADE_HOOKUP_OBJECT (config_win, label9, "label9"); + GLADE_HOOKUP_OBJECT (config_win, label31, "label31"); + GLADE_HOOKUP_OBJECT (config_win, label32, "label32"); + GLADE_HOOKUP_OBJECT (config_win, label33, "label33"); + GLADE_HOOKUP_OBJECT (config_win, label34, "label34"); + GLADE_HOOKUP_OBJECT (config_win, output_help_label, "output_help_label"); + GLADE_HOOKUP_OBJECT (config_win, config_devices_label, "config_devices_label"); + GLADE_HOOKUP_OBJECT (config_win, config_effects_page, "config_effects_page"); + GLADE_HOOKUP_OBJECT (config_win, ep_plugin_frame, "ep_plugin_frame"); + GLADE_HOOKUP_OBJECT (config_win, ep_plugin_vbox, "ep_plugin_vbox"); + GLADE_HOOKUP_OBJECT (config_win, ep_plugin_optionmenu, "ep_plugin_optionmenu"); + GLADE_HOOKUP_OBJECT (config_win, convertwidget7, "convertwidget7"); + GLADE_HOOKUP_OBJECT (config_win, convertwidget8, "convertwidget8"); + GLADE_HOOKUP_OBJECT (config_win, ep_plugin_buttonbox, "ep_plugin_buttonbox"); + GLADE_HOOKUP_OBJECT (config_win, ep_configure_button, "ep_configure_button"); + GLADE_HOOKUP_OBJECT (config_win, ep_about_button, "ep_about_button"); + GLADE_HOOKUP_OBJECT (config_win, ep_enable_check, "ep_enable_check"); + GLADE_HOOKUP_OBJECT (config_win, label10, "label10"); + GLADE_HOOKUP_OBJECT (config_win, effects_volnorm_frame, "effects_volnorm_frame"); + GLADE_HOOKUP_OBJECT (config_win, effects_volnorm_table, "effects_volnorm_table"); + GLADE_HOOKUP_OBJECT (config_win, volnorm_quantaudio_check, "volnorm_quantaudio_check"); + GLADE_HOOKUP_OBJECT (config_win, volnorm_target_spin, "volnorm_target_spin"); + GLADE_HOOKUP_OBJECT (config_win, volnorm_target_hbox, "volnorm_target_hbox"); + GLADE_HOOKUP_OBJECT (config_win, volnorm_target_label, "volnorm_target_label"); + GLADE_HOOKUP_OBJECT (config_win, volnorm_enable_check, "volnorm_enable_check"); + GLADE_HOOKUP_OBJECT (config_win, volnorm_rva2_check, "volnorm_rva2_check"); + GLADE_HOOKUP_OBJECT (config_win, label11, "label11"); + GLADE_HOOKUP_OBJECT (config_win, effects_help_label, "effects_help_label"); + GLADE_HOOKUP_OBJECT (config_win, config_effects_label, "config_effects_label"); + GLADE_HOOKUP_OBJECT (config_win, config_crossfader_page, "config_crossfader_page"); + GLADE_HOOKUP_OBJECT (config_win, xf_bufsize_hbox, "xf_bufsize_hbox"); + GLADE_HOOKUP_OBJECT (config_win, xf_bufsize_label, "xf_bufsize_label"); + GLADE_HOOKUP_OBJECT (config_win, xf_buffer_spin, "xf_buffer_spin"); + GLADE_HOOKUP_OBJECT (config_win, xf_autobuf_check, "xf_autobuf_check"); + GLADE_HOOKUP_OBJECT (config_win, xf_config_hbox, "xf_config_hbox"); + GLADE_HOOKUP_OBJECT (config_win, xf_config_label, "xf_config_label"); + GLADE_HOOKUP_OBJECT (config_win, xf_config_optionmenu, "xf_config_optionmenu"); + GLADE_HOOKUP_OBJECT (config_win, convertwidget9, "convertwidget9"); + GLADE_HOOKUP_OBJECT (config_win, convertwidget10, "convertwidget10"); + GLADE_HOOKUP_OBJECT (config_win, xf_type_hbox, "xf_type_hbox"); + GLADE_HOOKUP_OBJECT (config_win, xf_type_label, "xf_type_label"); + GLADE_HOOKUP_OBJECT (config_win, xf_type_optionmenu, "xf_type_optionmenu"); + GLADE_HOOKUP_OBJECT (config_win, convertwidget11, "convertwidget11"); + GLADE_HOOKUP_OBJECT (config_win, convertwidget12, "convertwidget12"); + GLADE_HOOKUP_OBJECT (config_win, xf_type_notebook, "xf_type_notebook"); + GLADE_HOOKUP_OBJECT (config_win, xft_reopen_label, "xft_reopen_label"); + GLADE_HOOKUP_OBJECT (config_win, xft_flush_page, "xft_flush_page"); + GLADE_HOOKUP_OBJECT (config_win, xftf_pause_frame, "xftf_pause_frame"); + GLADE_HOOKUP_OBJECT (config_win, xftf_pause_table, "xftf_pause_table"); + GLADE_HOOKUP_OBJECT (config_win, xftfp_length_label, "xftfp_length_label"); + GLADE_HOOKUP_OBJECT (config_win, xftfp_length_spin, "xftfp_length_spin"); + GLADE_HOOKUP_OBJECT (config_win, xftfp_enable_check, "xftfp_enable_check"); + GLADE_HOOKUP_OBJECT (config_win, label12, "label12"); + GLADE_HOOKUP_OBJECT (config_win, xftf_fadein_frame, "xftf_fadein_frame"); + GLADE_HOOKUP_OBJECT (config_win, xftf_fadein_table, "xftf_fadein_table"); + GLADE_HOOKUP_OBJECT (config_win, xftffi_length_hbox, "xftffi_length_hbox"); + GLADE_HOOKUP_OBJECT (config_win, xftffi_length_label, "xftffi_length_label"); + GLADE_HOOKUP_OBJECT (config_win, xftffi_volume_hbox, "xftffi_volume_hbox"); + GLADE_HOOKUP_OBJECT (config_win, xftffi_volume_label, "xftffi_volume_label"); + GLADE_HOOKUP_OBJECT (config_win, xftffi_length_spin, "xftffi_length_spin"); + GLADE_HOOKUP_OBJECT (config_win, xftffi_enable_check, "xftffi_enable_check"); + GLADE_HOOKUP_OBJECT (config_win, xftffi_volume_spin, "xftffi_volume_spin"); + GLADE_HOOKUP_OBJECT (config_win, label13, "label13"); + GLADE_HOOKUP_OBJECT (config_win, xft_flush_label, "xft_flush_label"); + GLADE_HOOKUP_OBJECT (config_win, xft_none_label, "xft_none_label"); + GLADE_HOOKUP_OBJECT (config_win, xft_pause_page, "xft_pause_page"); + GLADE_HOOKUP_OBJECT (config_win, xf_pause_frame, "xf_pause_frame"); + GLADE_HOOKUP_OBJECT (config_win, xf_pause_table, "xf_pause_table"); + GLADE_HOOKUP_OBJECT (config_win, pause_length_hbox, "pause_length_hbox"); + GLADE_HOOKUP_OBJECT (config_win, pause_length_label, "pause_length_label"); + GLADE_HOOKUP_OBJECT (config_win, pause_length_spin, "pause_length_spin"); + GLADE_HOOKUP_OBJECT (config_win, label14, "label14"); + GLADE_HOOKUP_OBJECT (config_win, xft_pause_label, "xft_pause_label"); + GLADE_HOOKUP_OBJECT (config_win, xft_simplexf_page, "xft_simplexf_page"); + GLADE_HOOKUP_OBJECT (config_win, xf_simple_frame, "xf_simple_frame"); + GLADE_HOOKUP_OBJECT (config_win, xf_simple_table, "xf_simple_table"); + GLADE_HOOKUP_OBJECT (config_win, simple_length_hbox, "simple_length_hbox"); + GLADE_HOOKUP_OBJECT (config_win, simple_length_label, "simple_length_label"); + GLADE_HOOKUP_OBJECT (config_win, simple_length_spin, "simple_length_spin"); + GLADE_HOOKUP_OBJECT (config_win, label15, "label15"); + GLADE_HOOKUP_OBJECT (config_win, xft_simplexf_label, "xft_simplexf_label"); + GLADE_HOOKUP_OBJECT (config_win, xft_advancedxf_page, "xft_advancedxf_page"); + GLADE_HOOKUP_OBJECT (config_win, xf_fadeout_frame, "xf_fadeout_frame"); + GLADE_HOOKUP_OBJECT (config_win, xf_fadeout_table, "xf_fadeout_table"); + GLADE_HOOKUP_OBJECT (config_win, fadeout_length_hbox, "fadeout_length_hbox"); + GLADE_HOOKUP_OBJECT (config_win, fadeout_length_label, "fadeout_length_label"); + GLADE_HOOKUP_OBJECT (config_win, fadeout_length_spin, "fadeout_length_spin"); + GLADE_HOOKUP_OBJECT (config_win, fadeout_volume_hbox, "fadeout_volume_hbox"); + GLADE_HOOKUP_OBJECT (config_win, fadeout_volume_label, "fadeout_volume_label"); + GLADE_HOOKUP_OBJECT (config_win, fadeout_volume_spin, "fadeout_volume_spin"); + GLADE_HOOKUP_OBJECT (config_win, fadeout_options_hbox, "fadeout_options_hbox"); + GLADE_HOOKUP_OBJECT (config_win, fadeout_enable_check, "fadeout_enable_check"); + GLADE_HOOKUP_OBJECT (config_win, label16, "label16"); + GLADE_HOOKUP_OBJECT (config_win, xf_offset_frame, "xf_offset_frame"); + GLADE_HOOKUP_OBJECT (config_win, xf_offset_table, "xf_offset_table"); + GLADE_HOOKUP_OBJECT (config_win, xfofs_custom_hbox, "xfofs_custom_hbox"); + GLADE_HOOKUP_OBJECT (config_win, xfofs_custom_radiobutton, "xfofs_custom_radiobutton"); + GLADE_HOOKUP_OBJECT (config_win, xfofs_custom_spin, "xfofs_custom_spin"); + GLADE_HOOKUP_OBJECT (config_win, xfofs_none_radiobutton, "xfofs_none_radiobutton"); + GLADE_HOOKUP_OBJECT (config_win, xfofs_lockout_radiobutton, "xfofs_lockout_radiobutton"); + GLADE_HOOKUP_OBJECT (config_win, xfofs_lockin_radiobutton, "xfofs_lockin_radiobutton"); + GLADE_HOOKUP_OBJECT (config_win, label17, "label17"); + GLADE_HOOKUP_OBJECT (config_win, xf_fadein_frame, "xf_fadein_frame"); + GLADE_HOOKUP_OBJECT (config_win, xf_fadein_table, "xf_fadein_table"); + GLADE_HOOKUP_OBJECT (config_win, fadein_length_hbox, "fadein_length_hbox"); + GLADE_HOOKUP_OBJECT (config_win, fadein_length_label, "fadein_length_label"); + GLADE_HOOKUP_OBJECT (config_win, fadein_volume_hbox, "fadein_volume_hbox"); + GLADE_HOOKUP_OBJECT (config_win, fadein_volume_label, "fadein_volume_label"); + GLADE_HOOKUP_OBJECT (config_win, fadein_length_spin, "fadein_length_spin"); + GLADE_HOOKUP_OBJECT (config_win, fadein_enable_check, "fadein_enable_check"); + GLADE_HOOKUP_OBJECT (config_win, fadein_lock_check, "fadein_lock_check"); + GLADE_HOOKUP_OBJECT (config_win, fadein_volume_spin, "fadein_volume_spin"); + GLADE_HOOKUP_OBJECT (config_win, label18, "label18"); + GLADE_HOOKUP_OBJECT (config_win, xft_advancedxf_label, "xft_advancedxf_label"); + GLADE_HOOKUP_OBJECT (config_win, xft_fadein_page, "xft_fadein_page"); + GLADE_HOOKUP_OBJECT (config_win, xftfi_fadein_frame, "xftfi_fadein_frame"); + GLADE_HOOKUP_OBJECT (config_win, xftfi_fadein_table, "xftfi_fadein_table"); + GLADE_HOOKUP_OBJECT (config_win, xftfi_length_hbox, "xftfi_length_hbox"); + GLADE_HOOKUP_OBJECT (config_win, xftfi_length_label, "xftfi_length_label"); + GLADE_HOOKUP_OBJECT (config_win, xftfi_volume_hbox, "xftfi_volume_hbox"); + GLADE_HOOKUP_OBJECT (config_win, xftfi_volume_label, "xftfi_volume_label"); + GLADE_HOOKUP_OBJECT (config_win, xftfi_length_spin, "xftfi_length_spin"); + GLADE_HOOKUP_OBJECT (config_win, xftfi_volume_spin, "xftfi_volume_spin"); + GLADE_HOOKUP_OBJECT (config_win, label19, "label19"); + GLADE_HOOKUP_OBJECT (config_win, xft_fadein_label, "xft_fadein_label"); + GLADE_HOOKUP_OBJECT (config_win, xft_fadeout_page, "xft_fadeout_page"); + GLADE_HOOKUP_OBJECT (config_win, xftfo_fadeout_frame, "xftfo_fadeout_frame"); + GLADE_HOOKUP_OBJECT (config_win, xftfo_fadeout_table, "xftfo_fadeout_table"); + GLADE_HOOKUP_OBJECT (config_win, xftfo_length_hbox, "xftfo_length_hbox"); + GLADE_HOOKUP_OBJECT (config_win, xftfo_length_label, "xftfo_length_label"); + GLADE_HOOKUP_OBJECT (config_win, xftfo_length_spin, "xftfo_length_spin"); + GLADE_HOOKUP_OBJECT (config_win, xftfo_volume_hbox, "xftfo_volume_hbox"); + GLADE_HOOKUP_OBJECT (config_win, xftfo_volume_label, "xftfo_volume_label"); + GLADE_HOOKUP_OBJECT (config_win, xftfo_volume_spin, "xftfo_volume_spin"); + GLADE_HOOKUP_OBJECT (config_win, label20, "label20"); + GLADE_HOOKUP_OBJECT (config_win, xftfo_silence_frame, "xftfo_silence_frame"); + GLADE_HOOKUP_OBJECT (config_win, xftfo_silence_table, "xftfo_silence_table"); + GLADE_HOOKUP_OBJECT (config_win, xftfo_silence_hbox, "xftfo_silence_hbox"); + GLADE_HOOKUP_OBJECT (config_win, xftfo_silence_label, "xftfo_silence_label"); + GLADE_HOOKUP_OBJECT (config_win, xftfo_silence_spin, "xftfo_silence_spin"); + GLADE_HOOKUP_OBJECT (config_win, label21, "label21"); + GLADE_HOOKUP_OBJECT (config_win, xft_fadeout_label, "xft_fadeout_label"); + GLADE_HOOKUP_OBJECT (config_win, xft_pause_none_label, "xft_pause_none_label"); + GLADE_HOOKUP_OBJECT (config_win, xft_pause_adv_page, "xft_pause_adv_page"); + GLADE_HOOKUP_OBJECT (config_win, xft_fadeoutin_frame, "xft_fadeoutin_frame"); + GLADE_HOOKUP_OBJECT (config_win, xft_fadeoutin_table, "xft_fadeoutin_table"); + GLADE_HOOKUP_OBJECT (config_win, xftfoi_fadeout_spin, "xftfoi_fadeout_spin"); + GLADE_HOOKUP_OBJECT (config_win, xftfoi_silence_spin, "xftfoi_silence_spin"); + GLADE_HOOKUP_OBJECT (config_win, xftfoi_fadein_spin, "xftfoi_fadein_spin"); + GLADE_HOOKUP_OBJECT (config_win, xftfoi_fadein_hbox, "xftfoi_fadein_hbox"); + GLADE_HOOKUP_OBJECT (config_win, xftfoi_fadein_label, "xftfoi_fadein_label"); + GLADE_HOOKUP_OBJECT (config_win, xftfoi_silence_hbox, "xftfoi_silence_hbox"); + GLADE_HOOKUP_OBJECT (config_win, xftfoi_silence_label, "xftfoi_silence_label"); + GLADE_HOOKUP_OBJECT (config_win, xftfoi_fadeout_hbox, "xftfoi_fadeout_hbox"); + GLADE_HOOKUP_OBJECT (config_win, xftfoi_fadeout_label, "xftfoi_fadeout_label"); + GLADE_HOOKUP_OBJECT (config_win, label22, "label22"); + GLADE_HOOKUP_OBJECT (config_win, xft_pause_adv_label, "xft_pause_adv_label"); + GLADE_HOOKUP_OBJECT (config_win, config_crossfade_label, "config_crossfade_label"); + GLADE_HOOKUP_OBJECT (config_win, config_gapkiller_page, "config_gapkiller_page"); + GLADE_HOOKUP_OBJECT (config_win, gap_leading_frame, "gap_leading_frame"); + GLADE_HOOKUP_OBJECT (config_win, gap_leading_table, "gap_leading_table"); + GLADE_HOOKUP_OBJECT (config_win, lgap_length_spin, "lgap_length_spin"); + GLADE_HOOKUP_OBJECT (config_win, lgap_level_spin, "lgap_level_spin"); + GLADE_HOOKUP_OBJECT (config_win, lgap_length_hbox, "lgap_length_hbox"); + GLADE_HOOKUP_OBJECT (config_win, lgap_length_label, "lgap_length_label"); + GLADE_HOOKUP_OBJECT (config_win, lgap_level_hbox, "lgap_level_hbox"); + GLADE_HOOKUP_OBJECT (config_win, lgap_level_label, "lgap_level_label"); + GLADE_HOOKUP_OBJECT (config_win, lgap_enable_check, "lgap_enable_check"); + GLADE_HOOKUP_OBJECT (config_win, label23, "label23"); + GLADE_HOOKUP_OBJECT (config_win, gap_trailing_frame, "gap_trailing_frame"); + GLADE_HOOKUP_OBJECT (config_win, gap_trailing_table, "gap_trailing_table"); + GLADE_HOOKUP_OBJECT (config_win, tgap_length_hbox, "tgap_length_hbox"); + GLADE_HOOKUP_OBJECT (config_win, tgap_length_label, "tgap_length_label"); + GLADE_HOOKUP_OBJECT (config_win, tgap_level_hbox, "tgap_level_hbox"); + GLADE_HOOKUP_OBJECT (config_win, tgap_level_label, "tgap_level_label"); + GLADE_HOOKUP_OBJECT (config_win, tgap_length_spin, "tgap_length_spin"); + GLADE_HOOKUP_OBJECT (config_win, tgap_level_spin, "tgap_level_spin"); + GLADE_HOOKUP_OBJECT (config_win, tgap_lock_check, "tgap_lock_check"); + GLADE_HOOKUP_OBJECT (config_win, tgap_enable_check, "tgap_enable_check"); + GLADE_HOOKUP_OBJECT (config_win, label24, "label24"); + GLADE_HOOKUP_OBJECT (config_win, gap_advanced_frame, "gap_advanced_frame"); + GLADE_HOOKUP_OBJECT (config_win, gap_advanced_vbox, "gap_advanced_vbox"); + GLADE_HOOKUP_OBJECT (config_win, gadv_crossing_check, "gadv_crossing_check"); + GLADE_HOOKUP_OBJECT (config_win, label25, "label25"); + GLADE_HOOKUP_OBJECT (config_win, config_gapkiller_label, "config_gapkiller_label"); + GLADE_HOOKUP_OBJECT (config_win, config_misc_page, "config_misc_page"); + GLADE_HOOKUP_OBJECT (config_win, misc_debug_frame, "misc_debug_frame"); + GLADE_HOOKUP_OBJECT (config_win, misc_debug_vbox, "misc_debug_vbox"); + GLADE_HOOKUP_OBJECT (config_win, debug_stderr_check, "debug_stderr_check"); + GLADE_HOOKUP_OBJECT (config_win, debug_monitor_check, "debug_monitor_check"); + GLADE_HOOKUP_OBJECT (config_win, label26, "label26"); + GLADE_HOOKUP_OBJECT (config_win, misc_mixopt_frame, "misc_mixopt_frame"); + GLADE_HOOKUP_OBJECT (config_win, misc_mixopt_vbox, "misc_mixopt_vbox"); + GLADE_HOOKUP_OBJECT (config_win, mixopt_enable_check, "mixopt_enable_check"); + GLADE_HOOKUP_OBJECT (config_win, mixopt_reverse_check, "mixopt_reverse_check"); + GLADE_HOOKUP_OBJECT (config_win, mixopt_software_check, "mixopt_software_check"); + GLADE_HOOKUP_OBJECT (config_win, label27, "label27"); + GLADE_HOOKUP_OBJECT (config_win, misc_other_frame, "misc_other_frame"); + GLADE_HOOKUP_OBJECT (config_win, misc_other_vbox, "misc_other_vbox"); + GLADE_HOOKUP_OBJECT (config_win, moth_songchange_hbox, "moth_songchange_hbox"); + GLADE_HOOKUP_OBJECT (config_win, moth_songchange_label, "moth_songchange_label"); + GLADE_HOOKUP_OBJECT (config_win, moth_songchange_spin, "moth_songchange_spin"); + GLADE_HOOKUP_OBJECT (config_win, moth_preload_hbox, "moth_preload_hbox"); + GLADE_HOOKUP_OBJECT (config_win, moth_preload_label, "moth_preload_label"); + GLADE_HOOKUP_OBJECT (config_win, moth_preload_spin, "moth_preload_spin"); + GLADE_HOOKUP_OBJECT (config_win, moth_noxf_hbox, "moth_noxf_hbox"); + GLADE_HOOKUP_OBJECT (config_win, moth_noxf_label, "moth_noxf_label"); + GLADE_HOOKUP_OBJECT (config_win, noxf_album_check, "noxf_album_check"); + GLADE_HOOKUP_OBJECT (config_win, noxf_samefile_check, "noxf_samefile_check"); + GLADE_HOOKUP_OBJECT (config_win, moth_httpworkaround_check, "moth_httpworkaround_check"); + GLADE_HOOKUP_OBJECT (config_win, moth_opmaxused_hbox, "moth_opmaxused_hbox"); + GLADE_HOOKUP_OBJECT (config_win, moth_opmaxused_check, "moth_opmaxused_check"); + GLADE_HOOKUP_OBJECT (config_win, moth_opmaxused_spin, "moth_opmaxused_spin"); + GLADE_HOOKUP_OBJECT (config_win, moth_quantaudio_check, "moth_quantaudio_check"); + GLADE_HOOKUP_OBJECT (config_win, moth_outputkeepopened_check, "moth_outputkeepopened_check"); + GLADE_HOOKUP_OBJECT (config_win, label28, "label28"); + GLADE_HOOKUP_OBJECT (config_win, config_misc_label, "config_misc_label"); + GLADE_HOOKUP_OBJECT (config_win, config_presets_page, "config_presets_page"); + GLADE_HOOKUP_OBJECT (config_win, presets_name_hbox, "presets_name_hbox"); + GLADE_HOOKUP_OBJECT (config_win, presets_name_entry, "presets_name_entry"); + GLADE_HOOKUP_OBJECT (config_win, presets_delete_button, "presets_delete_button"); + GLADE_HOOKUP_OBJECT (config_win, presets_new_button, "presets_new_button"); + GLADE_HOOKUP_OBJECT (config_win, presets_list_scrolledwindow, "presets_list_scrolledwindow"); + GLADE_HOOKUP_OBJECT (config_win, presets_list_list, "presets_list_list"); + GLADE_HOOKUP_OBJECT (config_win, presets_list_bbox, "presets_list_bbox"); + GLADE_HOOKUP_OBJECT (config_win, presets_load_button, "presets_load_button"); + GLADE_HOOKUP_OBJECT (config_win, presets_save_button, "presets_save_button"); + GLADE_HOOKUP_OBJECT (config_win, config_presets_label, "config_presets_label"); + GLADE_HOOKUP_OBJECT (config_win, config_bbox, "config_bbox"); + GLADE_HOOKUP_OBJECT (config_win, config_ok, "config_ok"); + GLADE_HOOKUP_OBJECT (config_win, config_cancel, "config_cancel"); + GLADE_HOOKUP_OBJECT (config_win, config_apply, "config_apply"); + GLADE_HOOKUP_OBJECT_NO_REF (config_win, tooltips, "tooltips"); + + return config_win; +} + +GtkWidget* +create_monitor_win (void) +{ + GtkWidget *monitor_win; + GtkWidget *monitor_table; + GtkWidget *monitor_output_hbox; + GtkWidget *monitor_output_progress; + GtkWidget *monitor_output_label2; + GtkWidget *monitor_displaylabel_hbox; + GtkWidget *monitor_display_label; + GtkWidget *monitor_position_hbox; + GtkWidget *monpos_position_label; + GtkWidget *monpos_label1; + GtkWidget *monpos_total_label; + GtkWidget *monpos_label2; + GtkWidget *monpos_left_label; + GtkWidget *monpos_label3; + GtkWidget *monpos_written_time_label; + GtkWidget *monpos_output_time_separator_label; + GtkWidget *monpos_output_time_label; + GtkWidget *monitor_outputlabel_hbox; + GtkWidget *monitor_output_label; + GtkWidget *monitor_positionlabel_hbox; + GtkWidget *monitor_position_label; + GtkWidget *monitor_display_frame; + GtkWidget *monitor_display_drawingarea; + + monitor_win = gtk_window_new (GTK_WINDOW_TOPLEVEL); + gtk_window_set_title (GTK_WINDOW (monitor_win), "Crossfade Buffer Monitor"); + gtk_window_set_default_size (GTK_WINDOW (monitor_win), 320, -1); + + monitor_table = gtk_table_new (3, 2, FALSE); + gtk_widget_show (monitor_table); + gtk_container_add (GTK_CONTAINER (monitor_win), monitor_table); + gtk_container_set_border_width (GTK_CONTAINER (monitor_table), 5); + gtk_table_set_row_spacings (GTK_TABLE (monitor_table), 3); + gtk_table_set_col_spacings (GTK_TABLE (monitor_table), 5); + + monitor_output_hbox = gtk_hbox_new (FALSE, 3); + gtk_widget_show (monitor_output_hbox); + gtk_table_attach (GTK_TABLE (monitor_table), monitor_output_hbox, 1, 2, 1, 2, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (GTK_FILL), 0, 0); + + monitor_output_progress = gtk_progress_bar_new (); + gtk_widget_show (monitor_output_progress); + gtk_box_pack_start (GTK_BOX (monitor_output_hbox), monitor_output_progress, TRUE, TRUE, 0); + + monitor_output_label2 = gtk_label_new ("ms"); + gtk_widget_show (monitor_output_label2); + gtk_box_pack_start (GTK_BOX (monitor_output_hbox), monitor_output_label2, FALSE, FALSE, 0); + gtk_label_set_justify (GTK_LABEL (monitor_output_label2), GTK_JUSTIFY_CENTER); + + monitor_displaylabel_hbox = gtk_hbox_new (FALSE, 0); + gtk_widget_show (monitor_displaylabel_hbox); + gtk_table_attach (GTK_TABLE (monitor_table), monitor_displaylabel_hbox, 0, 1, 0, 1, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (GTK_FILL), 0, 0); + + monitor_display_label = gtk_label_new ("Mixing Buffer:"); + gtk_widget_show (monitor_display_label); + gtk_box_pack_end (GTK_BOX (monitor_displaylabel_hbox), monitor_display_label, FALSE, FALSE, 0); + gtk_label_set_justify (GTK_LABEL (monitor_display_label), GTK_JUSTIFY_CENTER); + + monitor_position_hbox = gtk_hbox_new (FALSE, 0); + gtk_widget_show (monitor_position_hbox); + gtk_table_attach (GTK_TABLE (monitor_table), monitor_position_hbox, 1, 2, 2, 3, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (GTK_FILL), 0, 0); + + monpos_position_label = gtk_label_new ("-:--.-"); + gtk_widget_show (monpos_position_label); + gtk_box_pack_start (GTK_BOX (monitor_position_hbox), monpos_position_label, FALSE, FALSE, 0); + gtk_label_set_justify (GTK_LABEL (monpos_position_label), GTK_JUSTIFY_CENTER); + + monpos_label1 = gtk_label_new (" / "); + gtk_widget_show (monpos_label1); + gtk_box_pack_start (GTK_BOX (monitor_position_hbox), monpos_label1, FALSE, FALSE, 0); + gtk_label_set_justify (GTK_LABEL (monpos_label1), GTK_JUSTIFY_CENTER); + + monpos_total_label = gtk_label_new ("-:--"); + gtk_widget_show (monpos_total_label); + gtk_box_pack_start (GTK_BOX (monitor_position_hbox), monpos_total_label, FALSE, FALSE, 0); + gtk_label_set_justify (GTK_LABEL (monpos_total_label), GTK_JUSTIFY_CENTER); + + monpos_label2 = gtk_label_new (" total, "); + gtk_widget_show (monpos_label2); + gtk_box_pack_start (GTK_BOX (monitor_position_hbox), monpos_label2, FALSE, FALSE, 0); + gtk_label_set_justify (GTK_LABEL (monpos_label2), GTK_JUSTIFY_CENTER); + + monpos_left_label = gtk_label_new ("-:--"); + gtk_widget_show (monpos_left_label); + gtk_box_pack_start (GTK_BOX (monitor_position_hbox), monpos_left_label, FALSE, FALSE, 0); + gtk_label_set_justify (GTK_LABEL (monpos_left_label), GTK_JUSTIFY_CENTER); + + monpos_label3 = gtk_label_new (" left"); + gtk_widget_show (monpos_label3); + gtk_box_pack_start (GTK_BOX (monitor_position_hbox), monpos_label3, FALSE, FALSE, 0); + gtk_label_set_justify (GTK_LABEL (monpos_label3), GTK_JUSTIFY_CENTER); + + monpos_written_time_label = gtk_label_new ("-:--:--.-"); + gtk_widget_show (monpos_written_time_label); + gtk_box_pack_end (GTK_BOX (monitor_position_hbox), monpos_written_time_label, FALSE, FALSE, 0); + gtk_label_set_justify (GTK_LABEL (monpos_written_time_label), GTK_JUSTIFY_CENTER); + + monpos_output_time_separator_label = gtk_label_new (" / "); + gtk_widget_show (monpos_output_time_separator_label); + gtk_box_pack_end (GTK_BOX (monitor_position_hbox), monpos_output_time_separator_label, FALSE, FALSE, 0); + gtk_label_set_justify (GTK_LABEL (monpos_output_time_separator_label), GTK_JUSTIFY_CENTER); + + monpos_output_time_label = gtk_label_new ("-:--.---"); + gtk_widget_show (monpos_output_time_label); + gtk_box_pack_end (GTK_BOX (monitor_position_hbox), monpos_output_time_label, FALSE, FALSE, 0); + gtk_label_set_justify (GTK_LABEL (monpos_output_time_label), GTK_JUSTIFY_CENTER); + + monitor_outputlabel_hbox = gtk_hbox_new (FALSE, 0); + gtk_widget_show (monitor_outputlabel_hbox); + gtk_table_attach (GTK_TABLE (monitor_table), monitor_outputlabel_hbox, 0, 1, 1, 2, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (GTK_FILL), 0, 0); + + monitor_output_label = gtk_label_new ("Output Buffer:"); + gtk_widget_show (monitor_output_label); + gtk_box_pack_end (GTK_BOX (monitor_outputlabel_hbox), monitor_output_label, FALSE, FALSE, 0); + gtk_label_set_justify (GTK_LABEL (monitor_output_label), GTK_JUSTIFY_CENTER); + + monitor_positionlabel_hbox = gtk_hbox_new (FALSE, 0); + gtk_widget_show (monitor_positionlabel_hbox); + gtk_table_attach (GTK_TABLE (monitor_table), monitor_positionlabel_hbox, 0, 1, 2, 3, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + + monitor_position_label = gtk_label_new ("Position:"); + gtk_widget_show (monitor_position_label); + gtk_box_pack_end (GTK_BOX (monitor_positionlabel_hbox), monitor_position_label, FALSE, FALSE, 0); + gtk_label_set_justify (GTK_LABEL (monitor_position_label), GTK_JUSTIFY_CENTER); + + monitor_display_frame = gtk_frame_new (NULL); + gtk_widget_show (monitor_display_frame); + gtk_table_attach (GTK_TABLE (monitor_table), monitor_display_frame, 1, 2, 0, 1, + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); + + monitor_display_drawingarea = gtk_drawing_area_new (); + gtk_widget_show (monitor_display_drawingarea); + gtk_container_add (GTK_CONTAINER (monitor_display_frame), monitor_display_drawingarea); + + g_signal_connect ((gpointer) monitor_win, "delete_event", + G_CALLBACK (on_monitor_win_delete_event), + NULL); + g_signal_connect ((gpointer) monitor_display_drawingarea, "expose_event", + G_CALLBACK (on_monitor_display_drawingarea_expose_event), + NULL); + + /* Store pointers to all widgets, for use by lookup_widget(). */ + GLADE_HOOKUP_OBJECT_NO_REF (monitor_win, monitor_win, "monitor_win"); + GLADE_HOOKUP_OBJECT (monitor_win, monitor_table, "monitor_table"); + GLADE_HOOKUP_OBJECT (monitor_win, monitor_output_hbox, "monitor_output_hbox"); + GLADE_HOOKUP_OBJECT (monitor_win, monitor_output_progress, "monitor_output_progress"); + GLADE_HOOKUP_OBJECT (monitor_win, monitor_output_label2, "monitor_output_label2"); + GLADE_HOOKUP_OBJECT (monitor_win, monitor_displaylabel_hbox, "monitor_displaylabel_hbox"); + GLADE_HOOKUP_OBJECT (monitor_win, monitor_display_label, "monitor_display_label"); + GLADE_HOOKUP_OBJECT (monitor_win, monitor_position_hbox, "monitor_position_hbox"); + GLADE_HOOKUP_OBJECT (monitor_win, monpos_position_label, "monpos_position_label"); + GLADE_HOOKUP_OBJECT (monitor_win, monpos_label1, "monpos_label1"); + GLADE_HOOKUP_OBJECT (monitor_win, monpos_total_label, "monpos_total_label"); + GLADE_HOOKUP_OBJECT (monitor_win, monpos_label2, "monpos_label2"); + GLADE_HOOKUP_OBJECT (monitor_win, monpos_left_label, "monpos_left_label"); + GLADE_HOOKUP_OBJECT (monitor_win, monpos_label3, "monpos_label3"); + GLADE_HOOKUP_OBJECT (monitor_win, monpos_written_time_label, "monpos_written_time_label"); + GLADE_HOOKUP_OBJECT (monitor_win, monpos_output_time_separator_label, "monpos_output_time_separator_label"); + GLADE_HOOKUP_OBJECT (monitor_win, monpos_output_time_label, "monpos_output_time_label"); + GLADE_HOOKUP_OBJECT (monitor_win, monitor_outputlabel_hbox, "monitor_outputlabel_hbox"); + GLADE_HOOKUP_OBJECT (monitor_win, monitor_output_label, "monitor_output_label"); + GLADE_HOOKUP_OBJECT (monitor_win, monitor_positionlabel_hbox, "monitor_positionlabel_hbox"); + GLADE_HOOKUP_OBJECT (monitor_win, monitor_position_label, "monitor_position_label"); + GLADE_HOOKUP_OBJECT (monitor_win, monitor_display_frame, "monitor_display_frame"); + GLADE_HOOKUP_OBJECT (monitor_win, monitor_display_drawingarea, "monitor_display_drawingarea"); + + return monitor_win; +} + +GtkWidget* +create_about_win (void) +{ + GtkWidget *about_win; + GtkWidget *about_vbox; + GtkWidget *about_label; + GtkWidget *about_actionarea; + GtkWidget *about_ok; + + about_win = gtk_dialog_new (); + gtk_window_set_title (GTK_WINDOW (about_win), "About XMMS Crossfade Plugin"); + gtk_window_set_type_hint (GTK_WINDOW (about_win), GDK_WINDOW_TYPE_HINT_DIALOG); + + about_vbox = GTK_DIALOG (about_win)->vbox; + gtk_widget_show (about_vbox); + + about_label = gtk_label_new ("dummy"); + gtk_widget_show (about_label); + gtk_box_pack_start (GTK_BOX (about_vbox), about_label, FALSE, FALSE, 0); + gtk_label_set_justify (GTK_LABEL (about_label), GTK_JUSTIFY_CENTER); + + about_actionarea = GTK_DIALOG (about_win)->action_area; + gtk_widget_show (about_actionarea); + gtk_button_box_set_layout (GTK_BUTTON_BOX (about_actionarea), GTK_BUTTONBOX_END); + + about_ok = gtk_button_new_with_mnemonic ("OK"); + gtk_widget_show (about_ok); + gtk_dialog_add_action_widget (GTK_DIALOG (about_win), about_ok, 0); + + g_signal_connect_swapped ((gpointer) about_ok, "clicked", + G_CALLBACK (gtk_widget_destroy), + GTK_OBJECT (about_win)); + g_signal_connect_after ((gpointer) about_ok, "leave", + G_CALLBACK (gtk_widget_hide), + NULL); + + /* Store pointers to all widgets, for use by lookup_widget(). */ + GLADE_HOOKUP_OBJECT_NO_REF (about_win, about_win, "about_win"); + GLADE_HOOKUP_OBJECT_NO_REF (about_win, about_vbox, "about_vbox"); + GLADE_HOOKUP_OBJECT (about_win, about_label, "about_label"); + GLADE_HOOKUP_OBJECT_NO_REF (about_win, about_actionarea, "about_actionarea"); + GLADE_HOOKUP_OBJECT (about_win, about_ok, "about_ok"); + + return about_win; +} + +GtkWidget* +create_help_win (void) +{ + GtkWidget *help_win; + GtkWidget *help_vbox; + GtkWidget *help_scrolledwindow; + GtkWidget *help_text; + GtkWidget *help_buttonbox; + GtkWidget *help_close_button; + + help_win = gtk_window_new (GTK_WINDOW_TOPLEVEL); + gtk_window_set_title (GTK_WINDOW (help_win), "Help"); + + help_vbox = gtk_vbox_new (FALSE, 0); + gtk_widget_show (help_vbox); + gtk_container_add (GTK_CONTAINER (help_win), help_vbox); + gtk_container_set_border_width (GTK_CONTAINER (help_vbox), 5); + + help_scrolledwindow = gtk_scrolled_window_new (NULL, NULL); + gtk_widget_show (help_scrolledwindow); + gtk_box_pack_start (GTK_BOX (help_vbox), help_scrolledwindow, TRUE, TRUE, 0); + GTK_WIDGET_UNSET_FLAGS (help_scrolledwindow, GTK_CAN_FOCUS); + gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (help_scrolledwindow), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS); + gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (help_scrolledwindow), GTK_SHADOW_IN); + + help_text = gtk_text_view_new (); + gtk_widget_show (help_text); + gtk_container_add (GTK_CONTAINER (help_scrolledwindow), help_text); + gtk_text_view_set_editable (GTK_TEXT_VIEW (help_text), FALSE); + gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (help_text), GTK_WRAP_WORD); + gtk_text_buffer_set_text (gtk_text_view_get_buffer (GTK_TEXT_VIEW (help_text)), "\n", -1); + + help_buttonbox = gtk_hbutton_box_new (); + gtk_widget_show (help_buttonbox); + gtk_box_pack_start (GTK_BOX (help_vbox), help_buttonbox, FALSE, FALSE, 0); + gtk_button_box_set_layout (GTK_BUTTON_BOX (help_buttonbox), GTK_BUTTONBOX_END); + gtk_box_set_spacing (GTK_BOX (help_buttonbox), 30); + + help_close_button = gtk_button_new_with_mnemonic ("Close"); + gtk_widget_show (help_close_button); + gtk_container_add (GTK_CONTAINER (help_buttonbox), help_close_button); + GTK_WIDGET_SET_FLAGS (help_close_button, GTK_CAN_DEFAULT); + + g_signal_connect ((gpointer) help_close_button, "clicked", + G_CALLBACK (on_help_close_button_clicked), + NULL); + + /* Store pointers to all widgets, for use by lookup_widget(). */ + GLADE_HOOKUP_OBJECT_NO_REF (help_win, help_win, "help_win"); + GLADE_HOOKUP_OBJECT (help_win, help_vbox, "help_vbox"); + GLADE_HOOKUP_OBJECT (help_win, help_scrolledwindow, "help_scrolledwindow"); + GLADE_HOOKUP_OBJECT (help_win, help_text, "help_text"); + GLADE_HOOKUP_OBJECT (help_win, help_buttonbox, "help_buttonbox"); + GLADE_HOOKUP_OBJECT (help_win, help_close_button, "help_close_button"); + + return help_win; +} + diff -ruN audacious-1.0.0.org/Plugins/Output/crossfade/interface-2.0.glade audacious-1.0.0/Plugins/Output/crossfade/interface-2.0.glade --- audacious-1.0.0.org/Plugins/Output/crossfade/interface-2.0.glade 1970-01-01 09:00:00.000000000 +0900 +++ audacious-1.0.0/Plugins/Output/crossfade/interface-2.0.glade 2006-04-17 19:48:34.000000000 +0900 @@ -0,0 +1,5513 @@ + + + + + + + True + Crossfade Configuration + GTK_WINDOW_TOPLEVEL + GTK_WIN_POS_NONE + False + True + False + True + False + False + GDK_WINDOW_TYPE_HINT_NORMAL + GDK_GRAVITY_NORTH_WEST + True + False + + + + 10 + True + False + 10 + + + + True + True + True + True + GTK_POS_TOP + False + False + + + + 5 + True + False + 5 + + + + True + False + 6 + + + + True + 0 + 0.5 + GTK_SHADOW_ETCHED_IN + + + + 5 + True + 2 + 2 + False + 2 + 2 + + + + True + False + 0 + + + + True + Rate: + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + 0 + False + False + GTK_PACK_END + + + + + 0 + 1 + 0 + 1 + + + + + + True + False + 0 + + + + True + Quality: + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + 0 + False + False + GTK_PACK_END + + + + + 0 + 1 + 1 + 2 + fill + + + + + + True + True + -1 + + + 1 + 2 + 0 + 1 + fill + + + + + + + True + True + -1 + + + 1 + 2 + 1 + 2 + fill + + + + + + + + + True + Resampling + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + label_item + + + + + 0 + False + False + + + + + 0 + False + True + + + + + + True + False + False + GTK_POS_TOP + False + False + + + + True + False + 5 + + + + True + 0 + 0.5 + GTK_SHADOW_ETCHED_IN + + + + 5 + True + False + 2 + + + + True + True + 0 + + + + True + + + + True + dummy + True + + + + + + + 0 + False + False + + + + + + True + GTK_BUTTONBOX_START + 5 + + + + True + True + True + Configure + True + GTK_RELIEF_NORMAL + True + + + + + + + True + True + True + About + True + GTK_RELIEF_NORMAL + True + + + + + + 0 + False + True + + + + + + + + True + Output plugin + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + label_item + + + + + 0 + False + True + + + + + + True + 0 + 0.5 + GTK_SHADOW_ETCHED_IN + + + + 5 + True + False + 2 + + + + True + True + Throttle Output + True + GTK_RELIEF_NORMAL + True + False + False + True + + + + 0 + False + False + + + + + + True + False + 5 + + + + True + True + Max block size (bytes): + True + GTK_RELIEF_NORMAL + True + False + False + True + + + + 0 + False + False + + + + + + True + True + 10 + 0 + True + GTK_UPDATE_ALWAYS + True + False + 1024 4 1048580 4 16 10 + + + + 0 + True + True + + + + + 0 + True + True + + + + + + True + True + Force close/reopen on songchange + True + GTK_RELIEF_NORMAL + True + False + False + True + + + + 0 + False + False + + + + + + + + True + Plugin compatibility options + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + label_item + + + + + 0 + False + True + + + + + False + True + + + + + + True + + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + tab + + + + + + + + + + True + + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + tab + + + + + + + + + + True + + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + tab + + + + + + + + + + True + + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + tab + + + + + 0 + False + True + + + + + + True + When modifying the Output Options or the Mixing buffer size, you need to stop/restart playback for the settings to take effect. + False + False + GTK_JUSTIFY_LEFT + True + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + 0 + True + True + GTK_PACK_END + + + + + False + True + + + + + + True + Output + False + False + GTK_JUSTIFY_CENTER + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + tab + + + + + + 5 + True + False + 5 + + + + True + 0 + 0.5 + GTK_SHADOW_ETCHED_IN + + + + 5 + True + False + 2 + + + + True + Select an effect plugin. Take care not to use the same plugin as selected in Audacious' configuration dialog. + True + 0 + + + + True + + + + True + dummy + True + + + + + + + 0 + False + False + + + + + + True + GTK_BUTTONBOX_START + 5 + + + + True + Open the configuration dialog of the plugin selected above. + True + True + Configure + True + GTK_RELIEF_NORMAL + True + + + + + + + True + Open the about dialog of the plugin selected above. + True + True + About + True + GTK_RELIEF_NORMAL + True + + + + + + + True + Enable the selected plugin. Note that after pressing 'Apply' it may take a while until you can hear the effect, since it is applied before the audio data goes into the buffer. + True + Use plugin + True + GTK_RELIEF_NORMAL + True + False + False + True + + + + + + 0 + False + True + + + + + + + + True + Pre-mixing effect plugin + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + label_item + + + + + 0 + False + True + + + + + + 0 + 0.5 + GTK_SHADOW_ETCHED_IN + + + + 5 + True + 4 + 2 + False + 2 + 5 + + + + True + True + Read Quantaudio comment field + True + GTK_RELIEF_NORMAL + True + False + False + True + + + 1 + 2 + 2 + 3 + fill + + + + + + + True + Set the maximum length for gaps at the end of a stream. +Default: 500 + True + 0 + 0 + True + GTK_UPDATE_ALWAYS + False + False + 8000 0 32768 100 1000 10 + + + 1 + 2 + 3 + 4 + + + + + + + True + False + 0 + + + + True + Target RMS: + False + False + GTK_JUSTIFY_CENTER + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + 0 + False + False + + + + + 0 + 1 + 3 + 4 + fill + fill + + + + + + True + True + Enable + True + GTK_RELIEF_NORMAL + True + False + False + True + + + + 1 + 2 + 0 + 1 + fill + + + + + + + True + True + Read ID3V2 RVA2 Tag + True + GTK_RELIEF_NORMAL + True + False + False + True + + + 1 + 2 + 1 + 2 + fill + + + + + + + + + True + Volume normalizer + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + label_item + + + + + 0 + False + False + + + + + + True + You do not need to press 'Apply' after making changes to the effect plugin settings. It may take a while though until you can hear the change, since the plugin is applied before the mixing buffer. + False + False + GTK_JUSTIFY_LEFT + True + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + 0 + True + True + + + + + False + True + + + + + + True + Effects + False + False + GTK_JUSTIFY_CENTER + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + tab + + + + + + 5 + True + False + 2 + + + + True + False + 5 + + + + True + Mixing buffer size (ms): + False + False + GTK_JUSTIFY_CENTER + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + 0 + False + False + + + + + + True + Specify the size of the mixing buffer. Mixing buffer space is required for pauses, fade-outs, offsetting (i.e. interleaving the end and beginning of two songs) and killing trailing gaps. Fade-ins and killing leading gaps are done on-the-fly and do not depend on mixing buffer space. +Default: n/a - calculated automatically + True + 0 + 0 + True + GTK_UPDATE_ALWAYS + False + False + 8500 0 60000 100 1000 10 + + + + 0 + True + True + + + + + + True + Automatically calculate an optimal buffer size. +Default: On + True + auto + True + GTK_RELIEF_NORMAL + True + False + False + True + + + + 0 + False + False + + + + + 0 + False + False + + + + + + True + False + 5 + + + + True + Set parameters for: + False + False + GTK_JUSTIFY_CENTER + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + 0 + False + False + + + + + + True + Select the type of songchange you want to configure: +* Start of playback: When starting playback by pressing PLAY +* Automatic songchange: When reaching the end of a song and the playlist advances to the next song +* Manual songchange: When manually selecting another song, for example by pressing NEXT/PREV +* Manual stop: When pressing the STOP button +* End of playlist: After the last song in the playlist has been played +* Seeking: When seeking within the current song + True + 0 + + + + True + + + + True + dummy + True + + + + + + + 0 + True + True + + + + + 0 + False + False + + + + + + True + False + 5 + + + + True + Crossfade/Transition type: + False + False + GTK_JUSTIFY_CENTER + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + 0 + False + False + + + + + + True + Select the transition to be used for the songchange type selected above: +* Fade-in: Fade-in at 'Start of playback' +* Reopen output device: Force a close/open on the output plugin. This will most certainly re-introduce gaps and clicks, but might be usefull with some plugins. +* Flush output device: Keeps the output plugin opened, but flushes its buffers. This will give you almost instant reaction when pressing NEXT/PREV. +* None (gapless/off): Gapless mode. Keeps the device opened, but does not do any fading. +* Simple crossfade: Does a simple crossfade between the previous and the next song. +* Advanced crossfade: Allows you to configure the crossfade in more detail. +* Fade-out: Fade-out at 'Manual stop' or 'End of playlist'. + True + 0 + + + + True + + + + True + dummy + True + + + + + + + 0 + True + True + + + + + 0 + False + False + + + + + + True + False + False + GTK_POS_TOP + False + False + + + + + + + + True + Reopen + False + False + GTK_JUSTIFY_CENTER + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + tab + + + + + + True + False + 5 + + + + True + 0 + 0.5 + GTK_SHADOW_ETCHED_IN + + + + 5 + True + 2 + 2 + False + 2 + 5 + + + + True + Length (ms): + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + 0 + 1 + 1 + 2 + fill + + + + + + + True + Specify the length of the silence to be inserted between the tracks. +Default: 2000 + True + 0 + 0 + True + GTK_UPDATE_ALWAYS + False + False + 1000 0 60000 100 1000 10 + + + + 1 + 2 + 1 + 2 + + + + + + + True + True + Enable + True + GTK_RELIEF_NORMAL + True + False + False + True + + + + 1 + 2 + 0 + 1 + fill + + + + + + + + + True + Pause + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + label_item + + + + + 0 + False + False + + + + + + True + 0 + 0.5 + GTK_SHADOW_ETCHED_IN + + + + 5 + True + 3 + 2 + False + 2 + 5 + + + + True + False + 0 + + + + True + Length (ms): + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + 0 + False + False + + + + + 0 + 1 + 1 + 2 + fill + + + + + + True + False + 0 + + + + True + Start volume (%): + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + 0 + False + False + + + + + 0 + 1 + 2 + 3 + fill + + + + + + True + Set the duration for the fadein of the next song. + True + 0 + 0 + True + GTK_UPDATE_ALWAYS + False + False + 1000 0 60000 100 1000 10 + + + + 1 + 2 + 1 + 2 + + + + + + + True + True + Enable + True + GTK_RELIEF_NORMAL + True + False + False + True + + + + 1 + 2 + 0 + 1 + + + + + + + True + Set the start volume. Audacious-crossfade will fade from this volume to 100% during the time specified above. +Default: 0 + True + 0 + 0 + True + GTK_UPDATE_ALWAYS + False + False + 0 0 100 1 10 10 + + + + 1 + 2 + 2 + 3 + + + + + + + + + True + Fade in + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + label_item + + + + + 0 + False + False + + + + + False + True + + + + + + True + Flush + False + False + GTK_JUSTIFY_CENTER + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + tab + + + + + + + + + + True + None + False + False + GTK_JUSTIFY_CENTER + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + tab + + + + + + True + False + 5 + + + + True + 0 + 0.5 + GTK_SHADOW_ETCHED_IN + + + + 5 + True + 1 + 2 + False + 2 + 5 + + + + True + False + 0 + + + + True + Length (ms): + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + 0 + False + False + + + + + 0 + 1 + 0 + 1 + fill + + + + + + True + Specify the length of the silence to be inserted between the tracks. +Default: 2000 + True + 0 + 0 + True + GTK_UPDATE_ALWAYS + False + False + 1000 0 60000 100 1000 10 + + + + 1 + 2 + 0 + 1 + + + + + + + + + True + Pause + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + label_item + + + + + 0 + False + False + + + + + False + True + + + + + + True + Pause + False + False + GTK_JUSTIFY_CENTER + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + tab + + + + + + True + False + 5 + + + + True + 0 + 0.5 + GTK_SHADOW_ETCHED_IN + + + + 5 + True + 1 + 2 + False + 2 + 5 + + + + True + False + 0 + + + + True + Length (ms): + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + 0 + False + False + + + + + 0 + 1 + 0 + 1 + fill + + + + + + True + Specify the length of the crosssfade. +Default: depends on songchange type + True + 0 + 0 + True + GTK_UPDATE_ALWAYS + False + False + 1500 0 60000 100 1000 10 + + + + 1 + 2 + 0 + 1 + + + + + + + + + True + Crossfade + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + label_item + + + + + 0 + False + False + + + + + False + True + + + + + + True + Simple XF + False + False + GTK_JUSTIFY_CENTER + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + tab + + + + + + True + False + 5 + + + + True + 0 + 0.5 + GTK_SHADOW_ETCHED_IN + + + + 5 + True + 3 + 2 + False + 2 + 5 + + + + True + False + 0 + + + + True + Length (ms): + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + 0 + False + False + + + + + 0 + 1 + 1 + 2 + fill + + + + + + True + Set the duration for the fadeout of the previous song. + True + 0 + 0 + True + GTK_UPDATE_ALWAYS + False + False + 1000 0 60000 100 1000 10 + + + + 1 + 2 + 1 + 2 + + + + + + + True + False + 0 + + + + True + End volume (%): + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + 0 + False + False + + + + + 0 + 1 + 2 + 3 + fill + + + + + + True + Set the end volume. Audacious-crossfade will fade from 100% to this volume during the time specified above. +Default: 0 + True + 0 + 0 + True + GTK_UPDATE_ALWAYS + False + False + 0 0 100 1 10 10 + + + + 1 + 2 + 2 + 3 + + + + + + + True + False + 5 + + + + True + True + Enable + True + GTK_RELIEF_NORMAL + True + False + False + True + + + + 0 + False + False + + + + + 1 + 2 + 0 + 1 + fill + + + + + + + + True + Fade out + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + label_item + + + + + 0 + False + False + + + + + + True + 0 + 0.5 + GTK_SHADOW_ETCHED_IN + + + + 5 + True + 4 + 1 + False + 2 + 5 + + + + True + False + 5 + + + + True + Set a custom offset. + True + Custom (ms): + True + GTK_RELIEF_NORMAL + True + False + False + True + + + + + 0 + False + False + + + + + + True + Set how much the end of the previous and the beginning of the next song should overlap. +* Negative values indicate that the next song should start before the previous has reached the end. +* A value of 0 means that the songs are concatenated seamlessly. +* Positive values will yield insert silence inbetween.. + True + 0 + 0 + True + GTK_UPDATE_ALWAYS + False + False + -2000 -60000 60000 100 1000 10 + + + + 0 + True + True + + + + + 0 + 1 + 3 + 4 + fill + + + + + + True + Don't overlap the two songs. The next song will start immediatelly after the previous has ended. + True + None (0 ms) + True + GTK_RELIEF_NORMAL + True + False + False + True + xfofs_custom_radiobutton + + + + + 0 + 1 + 0 + 1 + + + + + + + True + Overlap by the fadeout duration specified above. + True + Lock to fadeout length + True + GTK_RELIEF_NORMAL + True + False + False + True + xfofs_custom_radiobutton + + + + + 0 + 1 + 1 + 2 + + + + + + + True + Overlap by the fadein duration specified below.. + True + Lock to fadein length + True + GTK_RELIEF_NORMAL + True + False + False + True + xfofs_custom_radiobutton + + + + + 0 + 1 + 2 + 3 + + + + + + + + + True + Offset + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + label_item + + + + + 0 + False + False + + + + + + True + 0 + 0.5 + GTK_SHADOW_ETCHED_IN + + + + 5 + True + 3 + 2 + False + 2 + 5 + + + + True + False + 0 + + + + True + Length (ms): + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + 0 + False + False + + + + + 0 + 1 + 1 + 2 + fill + + + + + + True + False + 0 + + + + True + Start volume (%): + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + 0 + False + False + + + + + 0 + 1 + 2 + 3 + fill + + + + + + True + Set the duration for the fadein of the next song. + True + 0 + 0 + True + GTK_UPDATE_ALWAYS + False + False + 1000 0 60000 100 1000 10 + + + + 1 + 2 + 1 + 2 + + + + + + + True + True + Enable + True + GTK_RELIEF_NORMAL + True + False + False + True + + + + 1 + 2 + 0 + 1 + + + + + + + True + Use the same settings as fade-out. + True + Lock to Fade-out + True + GTK_RELIEF_NORMAL + True + False + False + True + + + + 0 + 1 + 0 + 1 + fill + + + + + + + True + Set the start volume. Audacious-crossfade will fade from this volume to 100% during the time specified above. +Default: 0 + True + 0 + 0 + True + GTK_UPDATE_ALWAYS + False + False + 0 0 100 1 10 10 + + + + 1 + 2 + 2 + 3 + + + + + + + + + True + Fade in + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + label_item + + + + + 0 + False + False + + + + + False + True + + + + + + True + Advanced XF + False + False + GTK_JUSTIFY_CENTER + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + tab + + + + + + True + False + 0 + + + + True + 0 + 0.5 + GTK_SHADOW_ETCHED_IN + + + + 5 + True + 2 + 2 + False + 2 + 5 + + + + True + False + 0 + + + + True + Length (ms): + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + 0 + False + False + + + + + 0 + 1 + 0 + 1 + fill + + + + + + True + False + 0 + + + + True + Start volume (%): + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + 0 + False + False + + + + + 0 + 1 + 1 + 2 + fill + + + + + + True + Set the duration for the fadein when starting playback. + True + 0 + 0 + True + GTK_UPDATE_ALWAYS + False + False + 1000 0 60000 10 100 10 + + + + 1 + 2 + 0 + 1 + + + + + + + True + Set the start volume. Audacious-crossfade will fade from this volume to 100% during the time specified above. +Default: 0 + True + 0 + 0 + True + GTK_UPDATE_ALWAYS + False + False + 0 0 100 1 10 10 + + + + 1 + 2 + 1 + 2 + + + + + + + + + True + Fade in + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + label_item + + + + + 0 + False + False + + + + + False + True + + + + + + True + Fade in + False + False + GTK_JUSTIFY_CENTER + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + tab + + + + + + True + False + 5 + + + + True + 0 + 0.5 + GTK_SHADOW_ETCHED_IN + + + + 5 + True + 2 + 2 + False + 2 + 5 + + + + True + False + 0 + + + + True + Length (ms): + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + 0 + False + False + + + + + 0 + 1 + 0 + 1 + fill + + + + + + True + Set the duration for the fadeout of the last song. + True + 0 + 0 + True + GTK_UPDATE_ALWAYS + False + False + 500 0 60000 10 100 10 + + + + 1 + 2 + 0 + 1 + + + + + + + True + False + 0 + + + + True + End volume (%): + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + 0 + False + False + + + + + 0 + 1 + 1 + 2 + fill + + + + + + True + Set the end volume. Audacious-crossfade will fade from 100% to this volume during the time specified above. +Default: 0 + True + 0 + 0 + True + GTK_UPDATE_ALWAYS + False + False + 0 0 100 1 10 10 + + + + 1 + 2 + 1 + 2 + + + + + + + + + True + Fade out + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + label_item + + + + + 0 + False + False + + + + + + True + 0 + 0.5 + GTK_SHADOW_ETCHED_IN + + + + 5 + True + 1 + 2 + False + 2 + 5 + + + + True + False + 0 + + + + True + Length (ms): + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + 0 + False + False + + + + + 0 + 1 + 0 + 1 + fill + + + + + + True + Set how much additional silence should be played after the end of the last song. This way, you can avoid the clicks some soundcards produce when being shut down during playback. +Default: 500 + True + 0 + 0 + True + GTK_UPDATE_ALWAYS + False + False + 100 0 60000 10 100 10 + + + + 1 + 2 + 0 + 1 + + + + + + + + + True + Additional silence + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + label_item + + + + + 0 + False + False + + + + + False + True + + + + + + True + Fade out + False + False + GTK_JUSTIFY_CENTER + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + tab + + + + + + + + + + True + None + False + False + GTK_JUSTIFY_CENTER + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + tab + + + + + + True + False + 5 + + + + True + 0 + 0.5 + GTK_SHADOW_ETCHED_IN + + + + 5 + True + 3 + 2 + False + 2 + 5 + + + + True + Set the duration for the fadeout when pausing. +Default: 100 + + True + 0 + 0 + True + GTK_UPDATE_ALWAYS + False + False + 100 0 60000 10 100 10 + + + + 1 + 2 + 0 + 1 + + + + + + + True + Set how much additional silence should be played after pausing. This way, you can avoid the clicks some soundcards produce when entering pause. +Default: 100 + True + 0 + 0 + True + GTK_UPDATE_ALWAYS + False + False + 100 0 60000 10 100 10 + + + + 1 + 2 + 1 + 2 + + + + + + + True + Set the duration for the fadein when unpausing. +Default: 100 + True + 0 + 0 + True + GTK_UPDATE_ALWAYS + False + False + 100 0 60000 10 100 10 + + + + 1 + 2 + 2 + 3 + + + + + + + True + False + 0 + + + + True + Fade out (ms): + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + 0 + False + False + + + + + 0 + 1 + 0 + 1 + fill + + + + + + + True + False + 0 + + + + True + Silence (ms): + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + 0 + False + False + + + + + 0 + 1 + 1 + 2 + fill + + + + + + + True + False + 0 + + + + True + Fade in (ms): + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + 0 + False + False + + + + + 0 + 1 + 2 + 3 + fill + + + + + + + + + True + Fade out / Fade in + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + label_item + + + + + 0 + False + False + + + + + False + True + + + + + + True + Fade out / Fade in + False + False + GTK_JUSTIFY_CENTER + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + tab + + + + + 0 + False + False + + + + + False + True + + + + + + True + Crossfader + False + False + GTK_JUSTIFY_CENTER + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + tab + + + + + + 5 + True + False + 5 + + + + True + 0 + 0.5 + GTK_SHADOW_ETCHED_IN + + + + 5 + True + 3 + 2 + False + 2 + 5 + + + + True + Set the maximum length for gaps at the beginning of a stream. +Default: 500 + True + 0 + 0 + True + GTK_UPDATE_ALWAYS + False + False + 500 0 60000 10 100 10 + + + + 1 + 2 + 1 + 2 + + + + + + + True + Set the maximum volume for gaps at the beginning of a stream. All samples below this value are considered as silent. +Default: 512 + True + 0 + 0 + True + GTK_UPDATE_ALWAYS + False + False + 512 0 32767 16 256 10 + + + + 1 + 2 + 2 + 3 + + + + + + + True + False + 0 + + + + True + Max. length (ms): + False + False + GTK_JUSTIFY_CENTER + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + 0 + False + False + + + + + 0 + 1 + 1 + 2 + fill + fill + + + + + + True + False + 0 + + + + True + Max. level (16bit sample): + False + False + GTK_JUSTIFY_CENTER + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + 0 + False + False + + + + + 0 + 1 + 2 + 3 + fill + fill + + + + + + True + True + Enable + True + GTK_RELIEF_NORMAL + True + False + False + True + + + + 1 + 2 + 0 + 1 + fill + + + + + + + + + True + Leading gap killer + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + label_item + + + + + 0 + False + True + + + + + + True + 0 + 0.5 + GTK_SHADOW_ETCHED_IN + + + + 5 + True + 3 + 2 + False + 2 + 5 + + + + True + False + 0 + + + + True + Max. length (ms): + False + False + GTK_JUSTIFY_CENTER + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + 0 + False + False + + + + + 0 + 1 + 1 + 2 + fill + + + + + + True + False + 0 + + + + True + Max. level (16bit sample): + False + False + GTK_JUSTIFY_CENTER + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + 0 + False + False + + + + + 0 + 1 + 2 + 3 + fill + + + + + + True + Set the maximum length for gaps at the end of a stream. +Default: 500 + True + 0 + 0 + True + GTK_UPDATE_ALWAYS + False + False + 500 0 60000 10 100 10 + + + + 1 + 2 + 1 + 2 + + + + + + + True + Set the maximum volume for gaps at the end of a stream. All samples below this value are considered as silent. +Default: 512 + True + 0 + 0 + True + GTK_UPDATE_ALWAYS + False + False + 512 0 32767 1 16 10 + + + + 1 + 2 + 2 + 3 + + + + + + + True + Use the same settings as above. + True + Lock to Leading + True + GTK_RELIEF_NORMAL + True + False + False + True + + + + 0 + 1 + 0 + 1 + fill + + + + + + + True + True + Enable + True + GTK_RELIEF_NORMAL + True + False + False + True + + + + 1 + 2 + 0 + 1 + fill + + + + + + + + + True + Trailing gap killer + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + label_item + + + + + 0 + False + True + + + + + + True + 0 + 0.5 + GTK_SHADOW_ETCHED_IN + + + + 5 + True + False + 0 + + + + True + If enabled, Audacious-crossfade will take additional care to avoid clicks with pre-faded (gapless) tracks. Audacious-crossfade will cut off the end of the previous song (the beginning of the next song) only at a zero-crossing of the sample values. +Default: On + True + Skip to next zero crossing + True + GTK_RELIEF_NORMAL + True + False + False + True + + + 0 + False + False + + + + + + + + True + Advanced + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + label_item + + + + + 0 + False + False + + + + + False + True + + + + + + True + Gap Killer + False + False + GTK_JUSTIFY_CENTER + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + tab + + + + + + 5 + True + False + 5 + + + + True + 0 + 0.5 + GTK_SHADOW_ETCHED_IN + + + + 5 + True + False + 2 + + + + True + Monitors what is going on in Audacious-crossfade. If you think you found a bug in Audacious-crossfade, please enable this option and send me the output. +Note that you should disable debug output if you start Audacious from within Netscape. Netscape will spam you with dialogs containing the debug output captured from <stderr>. +Default: Off + True + Write debug output to <stderr> + True + GTK_RELIEF_NORMAL + True + False + False + True + + + 0 + False + False + + + + + + True + Enables the Buffer Monitor. This is a small window which shows how much data is in the buffers. The top display belongs to the mixing buffer, the bottom shows how much data is being buffered by the output plugin. +Default: Off + True + Show Buffer Monitor + True + GTK_RELIEF_NORMAL + True + False + False + True + + + 0 + False + False + + + + + + + + True + Debug options + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + label_item + + + + + 0 + False + False + + + + + + True + 0 + 0.5 + GTK_SHADOW_ETCHED_IN + + + + 5 + True + False + 2 + + + + True + Enables/disables Audacious volume and balance controls. +Default: On + True + Enable volume control + True + GTK_RELIEF_NORMAL + True + False + False + True + + + + 0 + False + False + + + + + + True + Reverses left and right with the balance control. +Default: Off + True + Reverse balance + True + GTK_RELIEF_NORMAL + True + False + False + True + + + 0 + False + False + + + + + + True + Enable software mixer. Usefull for output plugins without mixer support. +Default: Off + True + Software Mixer + True + GTK_RELIEF_NORMAL + True + False + False + True + + + 0 + False + False + + + + + + + + True + Volume control options + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + label_item + + + + + 0 + False + False + + + + + + True + 0 + 0.5 + GTK_SHADOW_ETCHED_IN + + + + 5 + True + False + 2 + + + + True + False + 5 + + + + True + False + Songchange timeout (ms): + False + False + GTK_JUSTIFY_CENTER + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + 0 + False + False + + + + + + True + False + The songchange timeout is the maximum time Audacious-crossfade waits for the next song. If this timeout is exceeded, the output plugin/device is closed. +Default: 500 + True + 0 + 0 + True + GTK_UPDATE_ALWAYS + False + False + 500 10 10000 10 100 10 + + + + 0 + True + True + + + + + 0 + True + True + + + + + + True + False + 5 + + + + True + Mixing buffer preload (ms): + False + False + GTK_JUSTIFY_CENTER + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + 0 + False + False + + + + + + True + Tells Audacious-crossfade how much data it should buffer before it starts writing to the output plugin/device. Usually, this value can be set to 0, because the output plugin does preloading on its own. +Default: 0 + True + 0 + 0 + True + GTK_UPDATE_ALWAYS + False + False + 0 0 60000 10 100 10 + + + 0 + True + True + + + + + 0 + True + True + + + + + + True + False + 5 + + + + True + Don't crossfade + False + False + GTK_JUSTIFY_CENTER + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + 0 + False + False + + + + + + True + This option enables the automatic detection of pre-faded or gapless tracks, like the tracks on some compilations or on most live albums. If such tracks are detected, crossfading will be disabled and only the gapkiller (if enabled) will be used for the songchange. +Default: On + True + successive tracks + True + GTK_RELIEF_NORMAL + True + False + False + True + + + 0 + False + False + + + + + + True + This option disables crossfading between the same file. This can happen if you have only one file in the playlist and 'repeat' turned on. +Default: Off + True + same file + True + GTK_RELIEF_NORMAL + True + False + False + True + + + 0 + False + False + + + + + 0 + False + False + + + + + + True + Enable this when you have problems playing internet HTTP audio streams. Unfortunatelly, it also breaks crossfading. +Default: Off + True + Enable HTTP buffer underrun workaround + True + GTK_RELIEF_NORMAL + True + False + False + True + + + 0 + False + False + + + + + + True + False + 5 + + + + True + With this option enabled, Audacious-crossfade will limit the amount of data being buffered by the output plugin. This way, you can decrease the latency between pressing STOP/NEXT/PREV and the new song actually being played. +Default: Off + True + Limit OP buffer usage (ms): + True + GTK_RELIEF_NORMAL + True + False + False + True + + + + 0 + False + False + + + + + + True + Beware that setting this value too low also increases the chance of buffer underruns. +Default: 250 + True + 0 + 0 + True + GTK_UPDATE_ALWAYS + False + False + 500 10 10000 10 100 10 + + + 0 + True + True + + + + + 0 + True + True + + + + + + Enable this when you have problems playing internet HTTP audio streams. Unfortunatelly, it also breaks crossfading. +Default: Off + True + Use Quantaudio timing comments + True + GTK_RELIEF_NORMAL + True + False + False + True + + + 0 + False + False + + + + + + True + Keep the output device opened all the time, even if Audacious is stopped. This way, you can avoid clicks caused by the soundcard when the device is opened or closed +Default: Off + True + Keep output opened + True + GTK_RELIEF_NORMAL + True + False + False + True + + + 0 + False + False + + + + + + + + True + Advanced options + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + label_item + + + + + 0 + False + True + + + + + False + True + + + + + + True + Advanced + False + False + GTK_JUSTIFY_CENTER + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + tab + + + + + + 5 + False + 5 + + + + True + False + 5 + + + + True + True + True + True + 0 + + True + * + False + + + 0 + True + True + + + + + + True + True + Delete + True + GTK_RELIEF_NORMAL + True + + + 0 + False + False + + + + + + True + True + New + True + GTK_RELIEF_NORMAL + True + + + 0 + False + False + + + + + 0 + False + False + + + + + + True + GTK_POLICY_AUTOMATIC + GTK_POLICY_ALWAYS + GTK_SHADOW_IN + GTK_CORNER_TOP_LEFT + + + + True + True + True + False + False + True + False + False + False + + + + + + 0 + True + True + + + + + + True + GTK_BUTTONBOX_END + 5 + + + + True + True + True + Load + True + GTK_RELIEF_NORMAL + True + + + + + + True + True + True + Save + True + GTK_RELIEF_NORMAL + True + + + + + 0 + False + False + + + + + False + True + + + + +