changeset 40:1788f4ce6a44

Numerous changes towards 0.8
author Matti Hamalainen <ccr@tnsp.org>
date Thu, 19 Jun 2003 22:38:01 +0000
parents 85a7753e2a9a
children c145ff12f2d0
files src/.cvsignore src/.cvsignore src/Makefile.am src/Makefile.am src/xmms-sid.cc src/xmms-sid.cc src/xmms-sid.h src/xmms-sid.h src/xs_config.c src/xs_config.c src/xs_config.h src/xs_config.h src/xs_fileinfo.cc src/xs_fileinfo.cc src/xs_genui.c src/xs_genui.c src/xs_genui.h src/xs_genui.h src/xs_init.c src/xs_init.c src/xs_length.c src/xs_length.c src/xs_stil.c src/xs_stil.c src/xs_support.c src/xs_support.c
diffstat 13 files changed, 587 insertions(+), 612 deletions(-) [+]
line wrap: on
line diff
--- a/src/.cvsignore	Thu Jun 19 20:49:01 2003 +0000
+++ b/src/.cvsignore	Thu Jun 19 22:38:01 2003 +0000
@@ -7,3 +7,4 @@
 xs_glade.*
 xs_interface.*
 config.h*
+*.lo
\ No newline at end of file
--- a/src/Makefile.am	Thu Jun 19 20:49:01 2003 +0000
+++ b/src/Makefile.am	Thu Jun 19 22:38:01 2003 +0000
@@ -2,18 +2,17 @@
 lib_LTLIBRARIES = libxmmssid.la
 
 # Generals
-AM_CFLAGS   = -D_REENTRANT @GTK_CFLAGS@ @SIDPLAY_CFLAGS@
+AM_CFLAGS   = -D_REENTRANT @GTK_CFLAGS@ @SIDPLAY1_INCLUDES@ @SIDPLAY2_INCLUDES@
 AM_CXXFLAGS = $(AM_CFLAGS)
 
 libxmmssid_la_LDFLAGS = -module -avoid-version
-libxmmssid_la_LIBADD  = @GTK_LIBS@ @PTHREAD_LIBS@ @SIDPLAY_LIBS@ -lstdc++
+libxmmssid_la_LIBADD  = @GTK_LIBS@ @PTHREAD_LIBS@ @SIDPLAY1_LDADD@ @SIDPLAY2_LDADD@ -lstdc++
 
 # Plugin sources
 libxmmssid_la_SOURCES =	\
 	xmms-sid.cc	xmms-sid.h	\
 	xs_init.c	\
 	xs_about.c	\
-	xs_title.cc	xs_title.h	\
 	xs_support.c	xs_support.h	\
 	xs_config.c	xs_config.h	\
 	xs_md5.c	xs_md5.h	\
@@ -21,4 +20,3 @@
 	xs_genui.c	xs_genui.h	\
 	xs_glade.c	xs_glade.h	\
 	xs_interface.c	xs_interface.h
-#	xs_stil.c	xs_stil.h	\
--- a/src/xmms-sid.cc	Thu Jun 19 20:49:01 2003 +0000
+++ b/src/xmms-sid.cc	Thu Jun 19 22:38:01 2003 +0000
@@ -19,7 +19,7 @@
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */
-
+extern "C" {
 #include <pthread.h>
 #include <stdlib.h>
 #include <string.h>
@@ -27,30 +27,44 @@
 #include <errno.h>
 #include <xmms/plugin.h>
 #include <xmms/util.h>
+#include <xmms/titlestring.h>
 #include "xmms-sid.h"
+#include "xs_support.h"
 #include "xs_config.h"
 #include "xs_length.h"
-#include "xs_title.h"
+}
 
-extern "C++" {
+#ifdef HAVE_SIDPLAY1
 #include <sidplay/player.h>
 #include <sidplay/myendian.h>
 #include <sidplay/fformat.h>
-}
+#endif
+
+#ifdef HAVE_SIDPLAY2
+#include <sidplay/sidplay2.h>
+#endif
 
 
 /*
  * Global variables
  */
+#ifdef HAVE_SIDPLAY1
 static struct emuConfig	xs_emuConf;
 static emuEngine	xs_emuEngine;
+typedef	sidTune		t_xs_tune;
+#endif
+
+#ifdef HAVE_SIDPLAY2
+#endif
+
 static pthread_t	xs_decode_thread;
 struct t_xs_cfg		xs_cfg;
 
 struct {
-	int	s_error, s_playing, s_songs, s_allownext;
-	sidTune	*s_tune;
-	gchar	*s_fname;
+	gboolean	isError, isPlaying, allowNext;
+	gint		currSong, nSongs;
+	t_xs_tune	*currTune;
+	gchar		*currFilename;
 } xs_status;
 
 pthread_mutex_t xs_mutex = PTHREAD_MUTEX_INITIALIZER;
@@ -66,29 +80,31 @@
  /* Initialize and get configuration */
  memset(&xs_cfg, 0, sizeof(xs_cfg));
 
- xs_get_configure();
+ xs_read_configuration();
 
- xs_status.s_error = 0;
- xs_status.s_playing = 0;
- xs_status.s_songs = 0;
- xs_status.s_allownext = 1;	// Initialize to TRUE to allow first song
- xs_status.s_tune = NULL;
- xs_status.s_fname = NULL;
+ xs_status.isError	= FALSE;
+ xs_status.isPlaying	= FALSE;
+ xs_status.nSongs	= 0;
+ xs_status.currSong	= 0;
+ xs_status.allowNext	= TRUE;	// Initialize to TRUE to allow first song
+ xs_status.currTune	= NULL;
+ xs_status.currFilename	= NULL;
 
- /* Try to initialize libSIDPlay */
- if (!xs_emuEngine)
+
+ /* Try to initialize libSIDPlay(s) */
+#ifdef HAVE_SIDPLAY1
+ if (!xs_emuEngine || !xs_emuEngine.verifyEndianess())
 	{
-	XSERR("Couldn't start SIDPlay emulator engine!\n");
+	XSERR("Couldn't start SIDPlay1 emulator engine!\n");
 	return;
 	}
+#endif
 
- if (!xs_emuEngine.verifyEndianess())
-	{
-	XSERR("Wrong hardware endianess (SIDPlay error)!\n");
-	return;
-	}
+#ifdef HAVE_SIDPLAY2
+#endif
 
  /* Read song-length database */
+ if (xs_cfg.songlenDBEnable)
  if (xs_songlen_init() < 0)
 	{
 	XSERR("Error initializing song-length database!\n");
@@ -112,6 +128,13 @@
  /* Stop playing */
  xs_plugin_ip.stop();
 
+ /* Shutdown libSIDPlay(s) */
+#ifdef HAVE_SIDPLAY1
+#endif
+
+#ifdef HAVE_SIDPLAY2
+#endif
+
  /* Close sub-song control window */
 
  /* Free allocated memory */
@@ -135,8 +158,8 @@
  /* Try to detect via libSIDPlay's detection routine, if required */
  if (xs_cfg.detectMagic)
 	{
-	sidTune *testTune = new sidTune(fileName);
-
+#ifdef HAVE_SIDPLAY1
+	t_xs_tune *testTune = new sidTune(fileName);
 	if (!testTune) return FALSE;
 	if (!testTune->getStatus())
 		{
@@ -146,9 +169,11 @@
 
 	delete testTune;
 	return TRUE;
+#endif
+#ifdef HAVE_SIDPLAY2
+#endif
 	}
 
-
  /* Detect just by checking filename extension */
  pcExt = strrchr(fileName, '.');
  if (pcExt)
@@ -170,152 +195,15 @@
  */
 static void *xs_play_loop(void *argPointer)
 {
- guchar			plr_data[XS_BUFSIZE];
- struct sidTuneInfo	plr_sidInf;
- gchar			*plr_tune_title = NULL;
- gint			plr_fxlen;
- enum AFormat		plr_fmt;
- gint			plr_tune_num;
- gint32			plr_tune_len;
-
-
  /* Don't allow next song to be set yet */
  pthread_mutex_lock(&xs_mutex);
- xs_status.s_allownext = 0;
+ xs_status.allowNext = FALSE;
  pthread_mutex_unlock(&xs_mutex);
 
 
- /* Check tune number */
- plr_tune_num = xs_status.s_playing;
 
- if (plr_tune_num <= 0)
-	plr_tune_num = 1;
-
-XSDEBUG("xs_play_loop(%d, %d)\n", plr_tune_num, xs_status.s_playing);
-
- /* Get song information */
- xs_status.s_tune->getInfo(plr_sidInf);
- plr_tune_len = xs_songlen_get(xs_status.s_fname, plr_tune_num);
- plr_tune_title = xs_filetitle_get(&plr_sidInf, plr_tune_num);
-
-XSDEBUG("title='%s', len=%d\n", plr_tune_title, plr_tune_len);
-
-
- /* Initialize audio output */
- // FIXME FIXME: FMT_S16_XXX -- different architechtures??
- // the patch may break something ...
- plr_fmt = (xs_emuConf.bitsPerSample == 16) ? FMT_S16_NE : FMT_U8;
-
-
- if (!xs_plugin_ip.output->open_audio(plr_fmt, xs_emuConf.frequency, xs_emuConf.channels))
-	{
-	pthread_mutex_lock(&xs_mutex);
-	xs_status.s_error = 1;
-	if (plr_tune_title) g_free(plr_tune_title);
-	if (xs_status.s_tune) delete xs_status.s_tune;
-	xs_status.s_allownext = 1;
-	pthread_mutex_unlock(&xs_mutex);
-	return NULL;
-	}
-
-
- /* Initialize the SIDPlay-emulator for song */
- if (!sidEmuInitializeSong(xs_emuEngine, *xs_status.s_tune, plr_tune_num))
-	{
-	XSERR("Couldn't initialize SIDPlay emulator engine! This may be a problem with your sound settings, or possibly a bug in XMMS-SID.\n");
-	pthread_mutex_lock(&xs_mutex);
-	xs_status.s_error = 1;
-	pthread_mutex_unlock(&xs_mutex);
-	goto pl_cleanup;
-	}
-
-
- /* Set song title information */
- xs_plugin_ip.set_info(
-	plr_tune_title, 
-	(plr_tune_len * 1000),
-	(1000 * (plr_sidInf.songSpeed ? plr_sidInf.songSpeed : (plr_sidInf.clockSpeed == SIDTUNE_CLOCK_NTSC) ? 60 : 50)),
-	xs_emuConf.frequency,
-	xs_emuConf.channels);
-
-
- /* Run playing loop: loop as long as xs_playing is same as current tune number */
- while (xs_status.s_playing == plr_tune_num)
-	{
-	plr_fxlen = XS_BUFSIZE;
-
-	/* Run emulator to fill output buffer with audio data */
-	sidEmuFillBuffer(xs_emuEngine, *xs_status.s_tune, plr_data, plr_fxlen);
-
-	/* If Max Playtime option set, check playtime */
-	if (xs_cfg.playUseMaxTime)
-		{
-		if ((xs_plugin_ip.output->output_time() / 1000) >= xs_cfg.playMaxTime)
-			{
-			pthread_mutex_lock(&xs_mutex);
-			xs_status.s_playing = 0;
-			pthread_mutex_unlock(&xs_mutex);
-			}
-		}
-
-	/* Check playtime against database */
-	if (xs_cfg.playMethod == XMMS_SID_PMETHOD_DATABASE)
-		{
-		if ((xs_plugin_ip.output->output_time() / 1000) >= plr_tune_len)
-			{
-			pthread_mutex_lock(&xs_mutex);
-			xs_status.s_playing = 0;
-			pthread_mutex_unlock(&xs_mutex);
-			}
-
-		}
-#if 0
-		else
-
-	/* Check for silence */
-	if (xs_cfg.playMethod == XMMS_SID_PMETHOD_MAXSILENCE)
-		{
-		}
-
-	/* Add static noise */
-
-	/* Muffle waveform (low-pass filter) */
-
-#endif
-
-
-		/* Send audio data to visualization plugin */
-		xs_plugin_ip.add_vis_pcm(xs_plugin_ip.output->written_time(),
-					plr_fmt, xs_emuConf.channels, plr_fxlen, plr_data);
-
-		/* Wait for a while */
-		while ((xs_status.s_playing == plr_tune_num) && (xs_plugin_ip.output->buffer_free() < plr_fxlen))
-			xmms_usleep(10000);
-
-
-		/* If playing, send final audio data to output plugin */
-		if (xs_status.s_playing == plr_tune_num)
-			xs_plugin_ip.output->write_audio(plr_data, plr_fxlen);
-
-	}	/* End of playerloop */
-
-
-pl_cleanup:
-	XSDEBUG("cleaning up...\n");
-
-	/* Cleanup & shutdown */
-	xs_plugin_ip.output->close_audio();
-
-	if (plr_tune_title) g_free(plr_tune_title);
-
-	pthread_mutex_lock(&xs_mutex);
-	xs_status.s_playing = 0;
-	if (xs_status.s_tune) delete xs_status.s_tune;
-	xs_status.s_allownext = 1;
-	pthread_mutex_unlock(&xs_mutex);
-
-	XSDEBUG("exiting thread, bye.\n");
-	return NULL;
+ XSDEBUG("exiting thread, bye.\n");
+ return NULL;
 }
 
 
@@ -324,20 +212,29 @@
  */
 void xs_play_file(char *fileName)
 {
- sidTune *newTune;
+ t_xs_tune *newTune;
  struct sidTuneInfo sidInf;
 
- XSDEBUG("request to start '%s'\n", fileName);
+ XSDEBUG("request to load '%s'\n", fileName);
+
 
- /* Wait until the previous song has finished for sure */
- if (!xs_status.s_allownext)
-	pthread_join(xs_decode_thread, NULL);
+ /* Initialize audio output */
+ XSDEBUG("opening audio output plugin...\n");
+ if (!xs_plugin_ip.output->open_audio(
+	((xs_cfg.fmtBitsPerSample == 16) ? FMT_S16_NE : FMT_U8), xs_cfg.fmtFrequency,
+	((xs_cfg.fmtChannels == XS_CHN_MONO) ? 1 : 2)))
+	{
+	XSERR("Couldn't open audio output plugin!\n");
+	delete newTune;
+	return;
+	}
+
 
  /* Try to get the tune */
  newTune = new sidTune(fileName);
  if (newTune == NULL) return;
 
- XSDEBUG("tune ok, status %i\n", xs_status.s_playing);
+ XSDEBUG("tune ok, configuring SIDPlay engine\n");
 
 
  /* Get current configuration */
@@ -347,19 +244,19 @@
  /* Configure channels and stuff */
  switch (xs_cfg.fmtChannels) {
 
-	case XMMS_SID_CHN_AUTOPAN:
+	case XS_CHN_AUTOPAN:
 		xs_emuConf.channels = SIDEMU_STEREO;
 		xs_emuConf.autoPanning = SIDEMU_CENTEREDAUTOPANNING;
 		xs_emuConf.volumeControl = SIDEMU_FULLPANNING;
 		break;
 
-	case XMMS_SID_CHN_STEREO:
+	case XS_CHN_STEREO:
 		xs_emuConf.channels = SIDEMU_STEREO;
 		xs_emuConf.autoPanning = SIDEMU_NONE;
 		xs_emuConf.volumeControl = SIDEMU_NONE;
 		break;
 
-	case XMMS_SID_CHN_MONO:
+	case XS_CHN_MONO:
 		xs_emuConf.channels = SIDEMU_MONO;
 		xs_emuConf.autoPanning = SIDEMU_NONE;
 		xs_emuConf.volumeControl = SIDEMU_NONE;
@@ -374,15 +271,15 @@
 
  /* Memory mode settings */
  switch (xs_cfg.memoryMode) {
-	case XMMS_SID_MPU_BANK_SWITCHING:
+	case XS_MPU_BANK_SWITCHING:
 		xs_emuConf.memoryMode = MPU_BANK_SWITCHING;
 		break;
 
-	case XMMS_SID_MPU_TRANSPARENT_ROM:
+	case XS_MPU_TRANSPARENT_ROM:
 		xs_emuConf.memoryMode = MPU_TRANSPARENT_ROM;
 		break;
 
-	case XMMS_SID_MPU_PLAYSID_ENVIRONMENT:
+	case XS_MPU_PLAYSID_ENVIRONMENT:
 		xs_emuConf.memoryMode = MPU_PLAYSID_ENVIRONMENT;
 		break;
 
@@ -395,11 +292,11 @@
 
  /* Clockspeed settings */
  switch (xs_cfg.clockSpeed) {
-	case XMMS_SID_CLOCK_PAL:
+	case XS_CLOCK_PAL:
 		xs_emuConf.clockSpeed = SIDTUNE_CLOCK_PAL;
 		break;
 
-	case XMMS_SID_CLOCK_NTSC:
+	case XS_CLOCK_NTSC:
 		xs_emuConf.clockSpeed = SIDTUNE_CLOCK_NTSC;
 		break;
 
@@ -415,7 +312,7 @@
  xs_emuConf.frequency		= xs_cfg.fmtFrequency;
  xs_emuConf.sampleFormat	= SIDEMU_SIGNED_PCM;
  xs_emuConf.mos8580		= xs_cfg.mos8580;
- xs_emuConf.emulateFilter	= xs_cfg.emulateFilter;
+ xs_emuConf.emulateFilter	= xs_cfg.emulateFilters;
  xs_emuConf.filterFs		= xs_cfg.filterFs;
  xs_emuConf.filterFm		= xs_cfg.filterFm;
  xs_emuConf.filterFt		= xs_cfg.filterFt;
@@ -429,14 +326,15 @@
 
 
  /* Initialize status information */
- XSDEBUG("starting thread!\n");
+ XSDEBUG("initializing and starting playing thread!\n");
 
- pthread_mutex_lock(&xs_mutex);
- xs_status.s_error = 0;
- xs_status.s_playing = sidInf.startSong;
- xs_status.s_songs = sidInf.songs;
- xs_status.s_tune = newTune;
- pthread_mutex_unlock(&xs_mutex);
+ xs_status.isError	= FALSE;
+ xs_status.isPlaying	= TRUE;
+ xs_status.allowNext	= TRUE;
+ xs_status.currSong	= sidInf.startSong;
+ xs_status.nSongs	= sidInf.songs;
+ xs_status.currTune	= newTune;
+
 
  /* Start the playing thread! */
  if (pthread_create(&xs_decode_thread, NULL, xs_play_loop, NULL) < 0)
@@ -455,13 +353,18 @@
 void xs_stop(void)
 {
  /* If playing, stop. */
- if (xs_status.s_playing)
+ XSDEBUG("request to stop.\n");
+
+ if (xs_status.isPlaying)
 	{
+	XSDEBUG("stopping...\n");
 	pthread_mutex_lock(&xs_mutex);
-	xs_status.s_playing = 0;
+	xs_status.isPlaying = 0;
 	pthread_mutex_unlock(&xs_mutex);
 
 	pthread_join(xs_decode_thread, NULL);
+
+	xs_plugin_ip.output->close_audio();
 	}
 }
 
@@ -482,12 +385,14 @@
 void xs_seek(int iTime)
 {
 #ifdef HAVE_SONG_POSITION
- if ((iTime > 0) && (iTime <= xs_songs))
+ pthread_mutex_lock(&xs_mutex);
+
+ if ((iTime > 0) && (iTime <= xs_status.nSongs) && xs_status.isPlaying)
 	{
-	pthread_mutex_lock(&xs_mutex);
-	xs_status.s_playing = iTime;
-	pthread_mutex_unlock(&xs_mutex);
+	xs_status.currSong = iTime;
 	}
+
+ pthread_mutex_unlock(&xs_mutex);
 #endif
 }
 
@@ -497,16 +402,19 @@
  */
 int xs_get_time(void)
 {
- if (xs_status.s_error)
+ pthread_mutex_lock(&xs_mutex);
+ if (xs_status.isError)
 	return -2;
 
- if (!xs_status.s_playing)
+ if (!xs_status.isPlaying)
 	return -1;
 
 #ifdef HAVE_SONG_POSITION
- set_song_position(xs_status.s_playing, 1, xs_status.s_songs);
+ set_song_position(xs_status.currSong, 1, xs_status.nSongs);
 #endif
 
+ pthread_mutex_unlock(&xs_mutex);
+
  return xs_plugin_ip.output->output_time();
 }
 
@@ -517,7 +425,7 @@
 void xs_get_song_info(char *songFilename, char **songTitle, int *songLength)
 {
  struct sidTuneInfo sidInf;
- sidTune *testTune = new sidTune(songFilename);
+ t_xs_tune *testTune = new sidTune(songFilename);
 
  /* Check if the tune exists and is readable */
  if (!testTune) return;
@@ -532,9 +440,108 @@
  delete testTune;
 
  /* Get titlestring */
- *songTitle = xs_filetitle_get(&sidInf, sidInf.startSong);
+ *songTitle = NULL;
 
- /* Get song length (in seconds), negative if no known length */
- *songLength = xs_songlen_get(songFilename, sidInf.startSong);
+ /* Get song length (in milliseconds), negative if no known length */
+ *songLength = xs_songlen_get(songFilename, sidInf.startSong) * 1000;
 }
 
+
+/*
+ * Create the SID-tune description string from the tune's information
+ * formatted by the user-specified format-string.
+ */
+gchar *xs_filetitle_get(gchar *pcFilename, void *pfInfo, gint iSubTune)
+{
+ gint i, j, iLength;
+ gchar *pcResult;
+ struct sidTuneInfo *finfo = (struct sidTuneInfo *) pfInfo;
+#ifdef HAVE_XMMSEXTRA
+ TitleInput *ptInput;
+#endif
+
+ // FIXME FIXME: get STIL-info
+	
+
+#ifdef HAVE_XMMSEXTRA
+ /* Check if the titles are overridden or not */
+ if (!xs_cfg.titleOverride)
+	{
+	/* Use generic XMMS titles */
+	/* XMMS_NEW_TITLEINPUT(ptInput);
+	 * We duplicate and add typecast to the code here due to XMMS's braindead headers
+	 */
+	ptInput = (TitleInput *) g_malloc0(sizeof(TitleInput));
+	ptInput->__size = XMMS_TITLEINPUT_SIZE;
+	ptInput->__version = XMMS_TITLEINPUT_VERSION;
+
+	/* Create the input fields */
+	ptInput->file_name	= pcFilename;
+	ptInput->file_ext	= pcFilename;
+	ptInput->file_path	= pcFilename;
+
+	ptInput->track_name	= finfo->nameString;
+	ptInput->track_number	= iSubTune;
+	ptInput->album_name	= NULL;
+	ptInput->performer	= finfo->authorString;
+	xs_strcalloc(&ptInput->date, "");
+	ptInput->year		= 0;
+	xs_strcalloc(&ptInput->genre, "SID-tune");
+	ptInput->comment	= finfo->copyrightString;
+
+	/* Create the string */
+	pcResult = xmms_get_titlestring(xmms_get_gentitle_format(), ptInput);
+
+	/* Dispose all allocated memory */
+	g_free(ptInput->date);
+	g_free(ptInput->genre);
+	g_free(ptInput);
+	} else {
+#endif
+	/* Check the info strings */
+	if (finfo->numberOfInfoStrings != 3)
+		{
+		if (finfo->numberOfInfoStrings < 1)
+			return 0;
+
+		return g_strdup(finfo->infoString[0]);
+		}
+
+	/* Check the format-string for NULL */
+	if (xs_cfg.titleFormat == NULL)
+		return g_strdup_printf("%s - %s", finfo->nameString, finfo->authorString);
+
+	/* Construct the final result info */
+	for (j = i = 0; i < strlen(xs_cfg.titleFormat); i++)
+		{
+		if (xs_cfg.titleFormat[i] == '%')
+			{
+			switch (xs_cfg.titleFormat[++i]) {
+			case '1':
+				xs_strpcat(&pcResult, &j, finfo->authorString);
+				break;
+
+			case '2':
+				xs_strpcat(&pcResult, &j, finfo->nameString);
+				break;
+
+			case '3':
+				xs_strpcat(&pcResult, &j, finfo->copyrightString);
+				break;
+
+			case '4':
+				xs_strpcat(&pcResult, &j, finfo->formatString);
+				break;
+			} /* case */
+			} else
+			pcResult[j++] = xs_cfg.titleFormat[i];
+		}
+
+	pcResult[j] = 0;
+#ifdef HAVE_XMMSEXTRA
+	}
+#endif
+
+ return pcResult;
+}
+
--- a/src/xmms-sid.h	Thu Jun 19 20:49:01 2003 +0000
+++ b/src/xmms-sid.h	Thu Jun 19 22:38:01 2003 +0000
@@ -32,13 +32,15 @@
 #include <config.h>
 #include <glib.h>
 #include <xmms/plugin.h>
+#include <assert.h>
 
 /*
  * Generals
  */
-#define XS_CONFIG_IDENT		"XMMS-SID"	/* Configuration file identifier */
 #define XS_BUFSIZE		(4096)		/* Size for some buffers */
 
+#define XS_MIN_OVERSAMPLE	(2)
+#define XS_MAX_OVERSAMPLE	(8)
 
 extern InputPlugin xs_plugin_ip;
 
@@ -56,7 +58,7 @@
 int	xs_get_time(void);
 void	xs_get_song_info(char *, char **, int *);
 // void	xs_file_info_box(char *);
-void	xs_aboutbox(void);
+void	xs_about(void);
 
 
 /*
--- a/src/xs_config.c	Thu Jun 19 20:49:01 2003 +0000
+++ b/src/xs_config.c	Thu Jun 19 22:38:01 2003 +0000
@@ -19,10 +19,9 @@
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */
+#include "xs_config.h"
 #include <xmms/configfile.h>
 #include <stdio.h>
-#include "xmms-sid.h"
-#include "xs_config.h"
 #include "xs_glade.h"
 #include "xs_interface.h"
 
@@ -30,51 +29,48 @@
 /*
  * Global widgets
  */
-static GtkWidget	*xs_configwin = NULL;
+static GtkWidget	*xs_configwin = NULL,
+			*xs_sldb_fileselector = NULL,
+			*xs_stil_fileselector = NULL;
+
+#define LUW(x...)	lookup_widget(xs_configwin, ## x)
 
 
 /*
  * Configuration specific stuff
  */
-#define XS_CFGTABLE_MAX	25
-
-t_xs_cfg_item xs_cfgtable[XS_CFGTABLE_MAX] = {
-	{ATYPE_INT, &xs_cfg.fmtBitsPerSample, "bitsPerSample"},
-	{ATYPE_INT, &xs_cfg.fmtChannels, "channels"},
-	{ATYPE_INT, &xs_cfg.fmtFrequency, "frequency"},
-
-	{ATYPE_BOOL,&xs_cfg.muffledOutput, "muffledOutput"},
-	{ATYPE_BOOL,&xs_cfg.addStaticNoise, "addStaticNoise"},
+t_xs_cfg_item xs_cfgtable[] = {
+	{ATYPE_INT,	&xs_cfg.fmtBitsPerSample,"bitsPerSample"},
+	{ATYPE_INT,	&xs_cfg.fmtChannels,	"channels"},
+	{ATYPE_INT,	&xs_cfg.fmtFrequency,	"frequency"},
 
-
-	{ATYPE_BOOL,  &xs_cfg.mos8580, "mos8580"},
-	{ATYPE_BOOL,  &xs_cfg.emulateFilter, "emulateFilter"},
-	{ATYPE_FLOAT, &xs_cfg.filterFs, "filterFs"},
-	{ATYPE_FLOAT, &xs_cfg.filterFm, "filterFm"},
-	{ATYPE_FLOAT, &xs_cfg.filterFt, "filterFt"},
-	{ATYPE_INT,   &xs_cfg.memoryMode, "memoryMode"},
-	{ATYPE_INT,   &xs_cfg.clockSpeed, "clockSpeed"},
-	{ATYPE_BOOL,  &xs_cfg.forceSpeed, "forceSpeed"},
+	{ATYPE_BOOL,	&xs_cfg.mos8580,	"mos8580"},
+	{ATYPE_BOOL,	&xs_cfg.emulateFilters,	"emulateFilters"},
+	{ATYPE_FLOAT,	&xs_cfg.filterFs,	"filterFs"},
+	{ATYPE_FLOAT,	&xs_cfg.filterFm,	"filterFm"},
+	{ATYPE_FLOAT,	&xs_cfg.filterFt,	"filterFt"},
+	{ATYPE_INT,	&xs_cfg.memoryMode,	"memoryMode"},
+	{ATYPE_INT,	&xs_cfg.clockSpeed,	"clockSpeed"},
+	{ATYPE_BOOL,	&xs_cfg.forceSpeed,	"forceSpeed"},
 
+	{ATYPE_BOOL,	&xs_cfg.oversampleEnable,"oversampleEnable"},
+	{ATYPE_INT,	&xs_cfg.oversampleFactor,"oversampleFactor"},
 
-	{ATYPE_BOOL,&xs_cfg.playUseMaxTime, "playUseMaxTime"},
-	{ATYPE_INT, &xs_cfg.playMaxTime, "playMaxTime"},
-	{ATYPE_INT, &xs_cfg.playMethod, "playMethod"},
-	{ATYPE_INT, &xs_cfg.playMaxSilentTime, "playMaxSilentTime"},
-	{ATYPE_INT, &xs_cfg.playSilentPercent, "playSilentPercent"},
-	{ATYPE_STR, &xs_cfg.playDBPath, "playDBPath"},
+	{ATYPE_BOOL,	&xs_cfg.playMaxTimeEnable,"playMaxTimeEnable"},
+	{ATYPE_INT,	&xs_cfg.playMaxTime,	"playMaxTime"},
+	{ATYPE_BOOL,	&xs_cfg.songlenDBEnable,"songlenDBEnable"},
+	{ATYPE_STR,	&xs_cfg.songlenDBPath,	"songlenDBPath"},
 
-	
-	{ATYPE_BOOL,&xs_cfg.useSTIL, "useSTIL"},
-	{ATYPE_STR, &xs_cfg.STILpath, "STILpath"},
+	{ATYPE_BOOL,	&xs_cfg.stilDBEnable,	"useSTIL"},
+	{ATYPE_STR,	&xs_cfg.stilDBPath,	"STILpath"},
+
+	{ATYPE_BOOL,	&xs_cfg.detectMagic,	"detectMagic"},
 
-	{ATYPE_BOOL, &xs_cfg.finfoUseColors, "useColors"},
-	{ATYPE_BOOL,&xs_cfg.detectMagic, "detectMagic"},
-
+	{ATYPE_BOOL,	&xs_cfg.titleOverride,	"titleOverride"},
+	{ATYPE_STR,	&xs_cfg.titleFormat,	"fileInfo"}
+};
 
-	{ATYPE_BOOL, &xs_cfg.titleOverride, "titleOverride"},
-	{ATYPE_STR, &xs_cfg.titleFormat, "fileInfo"}
-};
+const gint XS_CFGTABLE_MAX = (sizeof(xs_cfgtable) / sizeof(t_xs_cfg_item));
 
 
 /*
@@ -82,12 +78,11 @@
  */
 void xs_reset_filters(void)
 {
-	/* Reset filter values */
-// FIXME FIX ME
+ /* Reset filter values */
 /*
-	xs_cfg.filterFs = XMMS_SID_DEFAULT_FILTERFS;
-	xs_cfg.filterFm = XMMS_SID_DEFAULT_FILTERFM;
-	xs_cfg.filterFt = XMMS_SID_DEFAULT_FILTERFT;
+ xs_cfg.filterFs = SIDEMU_DEFAULTFILTERFS;
+ xs_cfg.filterFm = SIDEMU_DEFAULTFILTERFM;
+ xs_cfg.filterFt = SIDEMU_DEFAULTFILTERFT;
 */
 }
 
@@ -95,316 +90,331 @@
 /*
  * Get the configuration (from file or default)
  */
-void xs_get_configure(void)
+void xs_read_configuration(void)
 {
-	gchar *cfg_fn, *tmpstr;
-	ConfigFile *cfg_file;
-	gint i;
-
-	XSDEBUG("initializing configuration ...\n");
+ gchar *cfgFilename, *tmpStr;
+ ConfigFile *cfgFile;
+ gint i;
 
-	/* Pre-initialize configuration structure */
-	xs_cfg.fmtBitsPerSample = 16;
-	xs_cfg.fmtChannels = XMMS_SID_CHN_MONO;
-	xs_cfg.fmtFrequency = 44100;
+ XSDEBUG("initializing configuration ...\n");
 
-	xs_cfg.muffledOutput = FALSE;
-	xs_cfg.addStaticNoise = FALSE;
-
+ /* Pre-initialize configuration structure */
+ xs_cfg.fmtBitsPerSample		= 16;
+ xs_cfg.fmtChannels		= XS_CHN_MONO;
+ xs_cfg.fmtFrequency		= 44100;
 
-	xs_cfg.mos8580 = FALSE;
-	xs_cfg.emulateFilter = TRUE;
-	xs_reset_filters();
-	xs_cfg.memoryMode = XMMS_SID_MPU_BANK_SWITCHING;
-	xs_cfg.clockSpeed = XMMS_SID_CLOCK_PAL;
-	xs_cfg.forceSpeed = FALSE;
+ xs_cfg.mos8580			= FALSE;
+ xs_cfg.emulateFilters		= TRUE;
+ xs_reset_filters();
+ xs_cfg.memoryMode		= XS_MPU_BANK_SWITCHING;
+ xs_cfg.clockSpeed		= XS_CLOCK_PAL;
+ xs_cfg.forceSpeed		= FALSE;
 
+ xs_cfg.oversampleEnable	= FALSE;
+ xs_cfg.oversampleFactor	= XS_MIN_OVERSAMPLE;
 
-	xs_cfg.playUseMaxTime = FALSE;
-	xs_cfg.playMaxTime = 150;
-	xs_cfg.playMethod = XMMS_SID_PMETHOD_NONE;
-	xs_cfg.playMaxSilentTime = 20;
-	xs_cfg.playSilentPercent = 3;
-	xs_strcalloc(&xs_cfg.playDBPath, "~/C64Music/Songlength.txt");
+ xs_cfg.playMaxTimeEnable	= FALSE;
+ xs_cfg.playMaxTime		= 150;
+ xs_cfg.songlenDBEnable		= FALSE;
+ xs_strcalloc(&xs_cfg.songlenDBPath, "~/C64Music/Songlengths.txt");
 
+ xs_cfg.stilDBEnable		= FALSE;
+ xs_strcalloc(&xs_cfg.stilDBPath, "~/C64Music/DOCUMENTS/STIL.txt");
 
-	xs_cfg.useSTIL = FALSE;
-	xs_strcalloc(&xs_cfg.STILpath, "~/C64Music/DOCUMENTS/STIL.txt");
+ xs_cfg.detectMagic		= FALSE;
 
-	xs_cfg.finfoUseColors = TRUE;
-	xs_cfg.detectMagic = FALSE;
+ xs_cfg.titleOverride		= FALSE;
+ xs_strcalloc(&xs_cfg.titleFormat, "%1 - %2");
 
 
-	xs_cfg.titleOverride = FALSE;
-	xs_strcalloc(&xs_cfg.titleFormat, "%1 - %2");
-
-
-	/* Try to open the XMMS configuration file */
-	XSDEBUG("loading from config-file ...\n");
-
-	cfg_fn = g_strconcat(g_get_home_dir(), "/.xmms/config", NULL);
-	cfg_file = xmms_cfg_open_file(cfg_fn);
-	g_free(cfg_fn);
-	if (cfg_file == NULL) return;
-
-
-	/* Read the new settings from XMMS configuration file */
-	for (i = 0; i < XS_CFGTABLE_MAX; i++) {
-
-		switch (xs_cfgtable[i].atype) {
-		case ATYPE_INT:
-			xmms_cfg_read_int(cfg_file, XS_CONFIG_IDENT, xs_cfgtable[i].aname, (gint *) xs_cfgtable[i].adata);
-			break;
+ /* Try to open the XMMS configuration file */
+ XSDEBUG("loading from config-file ...\n");
 
-		case ATYPE_BOOL:
-			xmms_cfg_read_boolean(cfg_file, XS_CONFIG_IDENT, xs_cfgtable[i].aname, (gboolean *) xs_cfgtable[i].adata);
-			break;
-
-		case ATYPE_FLOAT:
-			xmms_cfg_read_float(cfg_file, XS_CONFIG_IDENT, xs_cfgtable[i].aname, (gfloat *) xs_cfgtable[i].adata);
-			break;
-
-		case ATYPE_STR:
-			if (xmms_cfg_read_string(cfg_file, XS_CONFIG_IDENT, xs_cfgtable[i].aname, (gchar **) &tmpstr))
-				{
-				/* Read was successfull */
-				xs_strcalloc((gchar **) xs_cfgtable[i].adata, tmpstr);
-				g_free(tmpstr);
-				}
-			break;
-
-		default:
-			XSERR("Internal: Unsupported setting type found while reading configuration file. Please report to author!\n");
-			break;
-		}
+ cfgFilename = g_strconcat(g_get_home_dir(), XS_CONFIG_FILE, NULL);
+ cfgFile = xmms_cfg_open_file(cfgFilename);
+ g_free(cfgFilename);
+ if (cfgFile == NULL)
+	{
+	XSDEBUG("could not open configuration file, trying to write defaults...\n");
+	xs_write_configuration();
+	return;
 	}
 
 
-	/* Free the config file */
-	xmms_cfg_free(cfg_file);
+ /* Read the new settings from XMMS configuration file */
+ for (i = 0; i < XS_CFGTABLE_MAX; i++)
+ 	{
+	switch (xs_cfgtable[i].atype) {
+	case ATYPE_INT:
+		xmms_cfg_read_int(cfgFile, XS_CONFIG_IDENT, xs_cfgtable[i].aname, (gint *) xs_cfgtable[i].adata);
+		break;
+
+	case ATYPE_BOOL:
+		xmms_cfg_read_boolean(cfgFile, XS_CONFIG_IDENT, xs_cfgtable[i].aname, (gboolean *) xs_cfgtable[i].adata);
+		break;
+
+	case ATYPE_FLOAT:
+		xmms_cfg_read_float(cfgFile, XS_CONFIG_IDENT, xs_cfgtable[i].aname, (gfloat *) xs_cfgtable[i].adata);
+		break;
 
-	XSDEBUG("OK\n");
+	case ATYPE_STR:
+		if (xmms_cfg_read_string(cfgFile, XS_CONFIG_IDENT, xs_cfgtable[i].aname, (gchar **) &tmpStr))
+			{
+			/* Read was successfull */
+			xs_strcalloc((gchar **) xs_cfgtable[i].adata, tmpStr);
+			g_free(tmpStr);
+			}
+		break;
+
+	default:
+		XSERR("Internal: Unsupported setting type found while reading configuration file. Please report to author!\n");
+		break;
+	}
+	}
+
+
+ /* Free the config file */
+ xmms_cfg_free(cfgFile);
+
+ xs_write_configuration();
+ 
+ XSDEBUG("OK\n");
 }
 
-#if 0
+
+
+/*
+ * Write the current configuration
+ */
+gint xs_write_configuration(void)
+{
+ gchar *cfgFilename;
+ ConfigFile *cfgFile;
+ gint i;
+
+ XSDEBUG("writing configuration ...\n");
+
+ /*
+  * Try to open the XMMS configuration file
+  */
+ cfgFilename = g_strconcat(g_get_home_dir(), XS_CONFIG_FILE, NULL);
+ cfgFile = xmms_cfg_open_file(cfgFilename);
+
+ if (!cfgFile)
+	cfgFile = xmms_cfg_new();
+
+
+ /* Write the new settings to XMMS configuration file */
+ for (i = 0; i < XS_CFGTABLE_MAX; i++)
+ 	{
+	switch (xs_cfgtable[i].atype) {
+	case ATYPE_INT:
+		xmms_cfg_write_int(cfgFile, XS_CONFIG_IDENT, xs_cfgtable[i].aname, *(gint *) xs_cfgtable[i].adata);
+		break;
+
+	case ATYPE_BOOL:
+		xmms_cfg_write_boolean(cfgFile, XS_CONFIG_IDENT, xs_cfgtable[i].aname, *(gboolean *) xs_cfgtable[i].adata);
+		break;
+
+	case ATYPE_FLOAT:
+		xmms_cfg_write_float(cfgFile, XS_CONFIG_IDENT, xs_cfgtable[i].aname, *(gfloat *) xs_cfgtable[i].adata);
+		break;
+
+	case ATYPE_STR:
+		xmms_cfg_write_string(cfgFile, XS_CONFIG_IDENT, xs_cfgtable[i].aname, *(gchar **) xs_cfgtable[i].adata);
+		break;
+
+	default:
+		XSERR("Internal: Unsupported setting type found while writing configuration file. Please report to author!\n");
+		break;
+	}
+	}
+
+ /* Flush the file */
+ xmms_cfg_write_file(cfgFile, cfgFilename);
+
+ /* Free the memory areas */
+ xmms_cfg_free(cfgFile);
+ g_free(cfgFilename);
+
+ return 0;
+}
+
+
 /*
  * Configuration panel was canceled
  */
-void xs_configure_cancel(void)
+void xs_cfg_cancel(void)
 {
-	gtk_widget_destroy(xs_configwin);
-	xs_configwin = NULL;
+ gtk_widget_destroy(xs_configwin);
+ xs_configwin = NULL;
 }
 
 
 /*
  * Configuration was accepted (OK), save the settings
  */
-void xs_configure_ok(void)
+void xs_cfg_ok(void)
 {
-	ConfigFile *cfg_file;
-	gchar *cfg_fn;
-	gint i;
+ XSDEBUG("get data from widgets to config...\n");
 
-	XSDEBUG("get data from widgets to config...\n");
-
-	/* Check the resolution settings */
-	if (GTK_TOGGLE_BUTTON(cfg_res_16bit)->active)
-		xs_cfg.fmtBitsPerSample = 16;
-	else if (GTK_TOGGLE_BUTTON(cfg_res_8bit)->active)
-		xs_cfg.fmtBitsPerSample = 8;
+ /* Check the resolution settings */
+ if (GTK_TOGGLE_BUTTON(LUW("cfg_res_16bit"))->active)
+	xs_cfg.fmtBitsPerSample = XS_RES_16BIT;
+	else
+	xs_cfg.fmtBitsPerSample = XS_RES_8BIT;
 
 
-	/* Channel settings */
-	if (GTK_TOGGLE_BUTTON(cfg_chn_mono)->active)
-		xs_cfg.fmtChannels = XMMS_SID_CHN_MONO;
-	else if (GTK_TOGGLE_BUTTON(cfg_chn_stereo)->active)
-		xs_cfg.fmtChannels = XMMS_SID_CHN_STEREO;
-	else if (GTK_TOGGLE_BUTTON(cfg_chn_autopan)->active)
-		xs_cfg.fmtChannels = XMMS_SID_CHN_AUTOPAN;
-
-	/* Frequency setting */
-	xs_cfg.fmtFrequency = (gint) GTK_ADJUSTMENT(cfg_samplerate_adj)->value;
-
-	/* Experimental settings */
-	xs_cfg.muffledOutput = GTK_TOGGLE_BUTTON(cfg_muffledoutput)->active;
-	xs_cfg.addStaticNoise = GTK_TOGGLE_BUTTON(cfg_addstaticnoise)->active;
+ /* Channel settings */
+ if (GTK_TOGGLE_BUTTON(LUW("cfg_chn_mono"))->active)
+	xs_cfg.fmtChannels = XS_CHN_MONO;
+	else
+ if (GTK_TOGGLE_BUTTON(LUW("cfg_chn_stereo"))->active)
+	xs_cfg.fmtChannels = XS_CHN_STEREO;
+	else
+ if (GTK_TOGGLE_BUTTON(LUW("cfg_chn_autopan"))->active)
+	xs_cfg.fmtChannels = XS_CHN_AUTOPAN;
 
 
-	/* Filter and waveform settings */
-	xs_cfg.mos8580 = ((GTK_TOGGLE_BUTTON(cfg_wav_mos8580)->active) && (!GTK_TOGGLE_BUTTON(cfg_wav_mos6581)->active));
-
-	xs_cfg.emulateFilter = GTK_TOGGLE_BUTTON(cfg_emufilters)->active;
-
-	xs_cfg.filterFs = GTK_ADJUSTMENT(cfg_filt_fs_adj)->value;
-	xs_cfg.filterFm = GTK_ADJUSTMENT(cfg_filt_fm_adj)->value;
-	xs_cfg.filterFt = GTK_ADJUSTMENT(cfg_filt_ft_adj)->value;
+ /* Frequency setting */
+ xs_cfg.fmtFrequency = (gint) GTK_ADJUSTMENT(LUW("cfg_samplerate_adj"))->value;
 
 
-	/* Memorymode settings */
-	if (GTK_TOGGLE_BUTTON(cfg_mem_banksw)->active)
-		xs_cfg.memoryMode = XMMS_SID_MPU_BANK_SWITCHING;
-	else if (GTK_TOGGLE_BUTTON(cfg_mem_transrom)->active)
-		xs_cfg.memoryMode = XMMS_SID_MPU_TRANSPARENT_ROM;
-	else if (GTK_TOGGLE_BUTTON(cfg_mem_playsid)->active)
-		xs_cfg.memoryMode = XMMS_SID_MPU_PLAYSID_ENVIRONMENT;
+ /* Filter and waveform settings */
+ xs_cfg.mos8580 = GTK_TOGGLE_BUTTON(LUW("cfg_wav_mos8580"))->active;
 
+ xs_cfg.emulateFilters = GTK_TOGGLE_BUTTON(LUW("cfg_emufilters"))->active;
 
-	/* Clockspeed settings */
-	if (GTK_TOGGLE_BUTTON(cfg_clock_pal)->active)
-		xs_cfg.clockSpeed = XMMS_SID_CLOCK_PAL;
-	else if (GTK_TOGGLE_BUTTON(cfg_clock_ntsc)->active)
-		xs_cfg.clockSpeed = XMMS_SID_CLOCK_NTSC;
-
-	xs_cfg.forceSpeed = GTK_TOGGLE_BUTTON(cfg_clock_force)->active;
+ xs_cfg.filterFs = GTK_ADJUSTMENT(LUW("cfg_filt_fs_adj"))->value;
+ xs_cfg.filterFm = GTK_ADJUSTMENT(LUW("cfg_filt_fm_adj"))->value;
+ xs_cfg.filterFt = GTK_ADJUSTMENT(LUW("cfg_filt_ft_adj"))->value;
 
 
-	/* Songlength-detection settings */
-	xs_cfg.playUseMaxTime = GTK_TOGGLE_BUTTON(cfg_sld_usemaxtime)->active;
-	xs_cfg.playMaxTime = GTK_ADJUSTMENT(cfg_sld_maxtime_adj)->value;
-
-	if (GTK_TOGGLE_BUTTON(cfg_sld_none)->active)
-		xs_cfg.playMethod = XMMS_SID_PMETHOD_NONE;
-	else if (GTK_TOGGLE_BUTTON(cfg_sld_maxsilence)->active)
-		xs_cfg.playMethod = XMMS_SID_PMETHOD_MAXSILENCE;
-	else if (GTK_TOGGLE_BUTTON(cfg_sld_database)->active)
-		xs_cfg.playMethod = XMMS_SID_PMETHOD_DATABASE;
-
-	xs_cfg.playMaxSilentTime = GTK_ADJUSTMENT(cfg_sld_silencetime_adj)->value;
-	xs_cfg.playSilentPercent = GTK_ADJUSTMENT(cfg_sld_percentage_adj)->value;
+ /* Memorymode settings */
+ if (GTK_TOGGLE_BUTTON(LUW("cfg_mem_banksw"))->active)
+	xs_cfg.memoryMode = XS_MPU_BANK_SWITCHING;
+	else
+ if (GTK_TOGGLE_BUTTON(LUW("cfg_mem_transrom"))->active)
+	xs_cfg.memoryMode = XS_MPU_TRANSPARENT_ROM;
+	else
+ if (GTK_TOGGLE_BUTTON(LUW("cfg_mem_playsid"))->active)
+	xs_cfg.memoryMode = XS_MPU_PLAYSID_ENVIRONMENT;
 
-	xs_strcalloc(&xs_cfg.playDBPath, gtk_entry_get_text(GTK_ENTRY(cfg_sld_dbpath)));
-
-
-	/* STIL and miscellaneous settings */
-	xs_cfg.useSTIL = GTK_TOGGLE_BUTTON(cfg_stil_use)->active;
-
-	xs_strcalloc(&xs_cfg.STILpath, gtk_entry_get_text(GTK_ENTRY(cfg_stil_path)));
+ /* Clockspeed settings */
+ if (GTK_TOGGLE_BUTTON(LUW("cfg_clock_ntsc"))->active)
+	xs_cfg.clockSpeed = XS_CLOCK_NTSC;
+	else
+	xs_cfg.clockSpeed = XS_CLOCK_PAL;
 
-	xs_cfg.finfoUseColors = GTK_TOGGLE_BUTTON(cfg_finfo_usecolors)->active;
-	xs_cfg.detectMagic = GTK_TOGGLE_BUTTON(cfg_detectmagic)->active;
-
-
-	/* Title settings */
-	xs_cfg.titleOverride = GTK_TOGGLE_BUTTON(cfg_ftitle_override)->active;
-
-	xs_strcalloc(&xs_cfg.titleFormat, gtk_entry_get_text(GTK_ENTRY(cfg_ftitle_format)));
+ xs_cfg.forceSpeed = GTK_TOGGLE_BUTTON(LUW("cfg_clock_force"))->active;
 
 
-	/*
-	 * Try to open the XMMS configuration file
-	 */
-	cfg_fn = g_strconcat(g_get_home_dir(), "/.xmms/config", NULL);
-	cfg_file = xmms_cfg_open_file(cfg_fn);
+ /* Songlength-detection settings */
+ xs_cfg.playMaxTimeEnable = GTK_TOGGLE_BUTTON(LUW("cfg_sld_usemaxtime"))->active;
+ xs_cfg.playMaxTime = GTK_ADJUSTMENT(LUW("cfg_sld_maxtime_adj"))->value;
 
-	if (!cfg_file)
-		cfg_file = xmms_cfg_new();
+ xs_cfg.songlenDBEnable = (GTK_TOGGLE_BUTTON(LUW("cfg_sld"))->active);
+ xs_strcalloc(&xs_cfg.songlenDBPath, gtk_entry_get_text(GTK_ENTRY(LUW("cfg_sld_dbpath"))));
 
 
-	/* Write the new settings to XMMS configuration file */
-	for (i = 0; i < XS_CFGTABLE_MAX; i++) {
-
-		switch (xs_cfgtable[i].atype) {
-		case ATYPE_INT:
-			xmms_cfg_write_int(cfg_file, XS_CONFIG_IDENT, xs_cfgtable[i].aname, *(gint *) xs_cfgtable[i].adata);
-			break;
+ /* STIL and miscellaneous settings */
+ xs_cfg.stilDBEnable = GTK_TOGGLE_BUTTON(LUW("cfg_stil_use"))->active;
+ xs_strcalloc(&xs_cfg.stilDBPath, gtk_entry_get_text(GTK_ENTRY(LUW("cfg_stil_path"))));
 
-		case ATYPE_BOOL:
-			xmms_cfg_write_boolean(cfg_file, XS_CONFIG_IDENT, xs_cfgtable[i].aname, *(gboolean *) xs_cfgtable[i].adata);
-			break;
+ xs_cfg.detectMagic = GTK_TOGGLE_BUTTON(LUW("cfg_detectmagic"))->active;
 
-		case ATYPE_FLOAT:
-			xmms_cfg_write_float(cfg_file, XS_CONFIG_IDENT, xs_cfgtable[i].aname, *(gfloat *) xs_cfgtable[i].adata);
-			break;
+ /* Title settings */
+ xs_cfg.titleOverride = GTK_TOGGLE_BUTTON(LUW("cfg_ftitle_override"))->active;
+ xs_strcalloc(&xs_cfg.titleFormat, gtk_entry_get_text(GTK_ENTRY(LUW("cfg_ftitle_format"))));
 
-		case ATYPE_STR:
-			xmms_cfg_write_string(cfg_file, XS_CONFIG_IDENT, xs_cfgtable[i].aname, *(gchar **) xs_cfgtable[i].adata);
-			break;
 
-		default:
-			XSERR("Internal: Unsupported setting type found while writing configuration file. Please report to author!\n");
-			break;
-		}
-
-	}
+ /* Write settings */
+ xs_write_configuration();
 
-	/* Flush the file */
-	xmms_cfg_write_file(cfg_file, cfg_fn);
+/* NOTICE/FIXME FIX ME: if songlendb or stildb settings changed, we need to flush and reread them */
 
-	/* Free the memory areas */
-	xmms_cfg_free(cfg_file);
-
-	g_free(cfg_fn);
-
-	gtk_widget_destroy(xs_configwin);
-	xs_configwin = NULL;
+ /* Close window */
+ gtk_widget_destroy(xs_configwin);
+ xs_configwin = NULL;
 }
 
 
 /*
  * Update filter setting sliders
  */
-static void xs_update_filters(void)
+void xs_update_filters(void)
 {
-	gtk_adjustment_set_value(GTK_ADJUSTMENT(cfg_filt_fs_adj), xs_cfg.filterFs);
-	gtk_adjustment_set_value(GTK_ADJUSTMENT(cfg_filt_fm_adj), xs_cfg.filterFm);
-	gtk_adjustment_set_value(GTK_ADJUSTMENT(cfg_filt_ft_adj), xs_cfg.filterFt);
+ gtk_adjustment_set_value(GTK_ADJUSTMENT(LUW("cfg_filt_fs_adj")), xs_cfg.filterFs);
+ gtk_adjustment_set_value(GTK_ADJUSTMENT(LUW("cfg_filt_fm_adj")), xs_cfg.filterFm);
+ gtk_adjustment_set_value(GTK_ADJUSTMENT(LUW("cfg_filt_ft_adj")), xs_cfg.filterFt);
 }
 
 
 /*
  * Reset filter settings to defaults
  */
-static void xs_cfg_filter_reset(void)
+void xs_cfg_filter_reset(void)
 {
-	xs_reset_filters();
-	xs_update_filters();
+ xs_reset_filters();
+ xs_update_filters();
 }
 
 
 /*
  * HVSC songlength-database file selector response-functions
  */
-void xs_cfg_sld_fs_ok(void)
+void xs_cfg_sld_dbbrowse(GtkButton *button, gpointer user_data)
 {
-	/* Selection was accepted! */
-	gtk_entry_set_text(GTK_ENTRY(cfg_sld_dbpath), gtk_file_selection_get_filename(GTK_FILE_SELECTION(xs_sld_fileselector))
-	    );
-
-	/* Close file selector window */
-	gtk_widget_destroy(xs_sld_fileselector);
-	xs_sld_fileselector = NULL;
 }
 
 
-void xs_cfg_sld_fs_cancel(void)
+void xs_cfg_sldb_fs_ok(void)
 {
-	/* Close file selector window */
-	gtk_widget_destroy(xs_sld_fileselector);
-	xs_sld_fileselector = NULL;
+ /* Selection was accepted! */
+ gtk_entry_set_text(GTK_ENTRY(LUW("cfg_sld_dbpath")),
+ 	gtk_file_selection_get_filename(GTK_FILE_SELECTION(xs_sldb_fileselector))
+ 	);
+
+ /* Close file selector window */
+ gtk_widget_destroy(xs_sldb_fileselector);
+ xs_sldb_fileselector = NULL;
+}
+
+
+void xs_cfg_sldb_fs_cancel(void)
+{
+ /* Close file selector window */
+ gtk_widget_destroy(xs_sldb_fileselector);
+ xs_sldb_fileselector = NULL;
 }
 
 
 /*
  * STIL-database file selector response-functions
  */
+void xs_cfg_stil_browse(GtkButton *button, gpointer user_data)
+{
+
+}
+
+
 void xs_cfg_stil_fs_ok(void)
 {
-	/* Selection was accepted! */
-	gtk_entry_set_text(GTK_ENTRY(cfg_stil_path), gtk_file_selection_get_filename(GTK_FILE_SELECTION(xs_stil_fileselector))
-	    );
+ /* Selection was accepted! */
+ gtk_entry_set_text(GTK_ENTRY(LUW("cfg_stil_path")),
+ 	gtk_file_selection_get_filename(GTK_FILE_SELECTION(xs_stil_fileselector)));
 
-	/* Close file selector window */
-	gtk_widget_destroy(xs_stil_fileselector);
-	xs_stil_fileselector = NULL;
+ /* Close file selector window */
+ gtk_widget_destroy(xs_stil_fileselector);
+ xs_stil_fileselector = NULL;
 }
 
 
 void xs_cfg_stil_fs_cancel(void)
 {
-	/* Close file selector window */
-	gtk_widget_destroy(xs_stil_fileselector);
-	xs_stil_fileselector = NULL;
+ /* Close file selector window */
+ gtk_widget_destroy(xs_stil_fileselector);
+ xs_stil_fileselector = NULL;
 }
 
 
@@ -413,15 +423,17 @@
  */
 void xs_configure(void)
 {
-
-	/* Check if the window already exists */
-	if (xs_configwin != NULL) {
-		gdk_window_raise(xs_configwin->window);
-		return;
+ /* Check if the window already exists */
+ if (xs_configwin != NULL)
+	{
+	gdk_window_raise(xs_configwin->window);
+	return;
 	}
 
-
-
+ /* Create the window */
+ xs_configwin = create_xs_configwin();
+ 	
+#if 0
 
 	/* Set the states of widgets */
 
@@ -454,15 +466,15 @@
 
 	/* Memorymode settings */
 	switch (xs_cfg.memoryMode) {
-	case XMMS_SID_MPU_BANK_SWITCHING:
+	case XS_MPU_BANK_SWITCHING:
 		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cfg_mem_banksw), TRUE);
 		break;
 
-	case XMMS_SID_MPU_TRANSPARENT_ROM:
+	case XS_MPU_TRANSPARENT_ROM:
 		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cfg_mem_transrom), TRUE);
 		break;
 
-	case XMMS_SID_MPU_PLAYSID_ENVIRONMENT:
+	case XS_MPU_PLAYSID_ENVIRONMENT:
 		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cfg_mem_playsid), TRUE);
 		break;
 	}
@@ -485,16 +497,16 @@
 
 	/* Song-length detection */
 	switch (xs_cfg.playMethod) {
-	case XMMS_SID_PMETHOD_NONE:
+	case XS_PMETHOD_NONE:
 		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cfg_sld_none), TRUE);
 		break;
 
-	case XMMS_SID_PMETHOD_MAXSILENCE:
+	case XS_PMETHOD_MAXSILENCE:
 		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cfg_sld_maxsilence), TRUE);
 		break;
 
 
-	case XMMS_SID_PMETHOD_DATABASE:
+	case XS_PMETHOD_DATABASE:
 		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cfg_sld_database), TRUE);
 		break;
 	}
@@ -539,11 +551,8 @@
 		gtk_entry_set_text(GTK_ENTRY(cfg_ftitle_format), xs_cfg.titleFormat);
 		}
 
+#endif
 
-	gtk_widget_show(xs_configwin);
+ gtk_widget_show(xs_configwin);
 }
 
-#endif
-void xs_configure(void)
-{
-}
--- a/src/xs_config.h	Thu Jun 19 20:49:01 2003 +0000
+++ b/src/xs_config.h	Thu Jun 19 22:38:01 2003 +0000
@@ -5,74 +5,86 @@
 extern "C" {
 #endif
 
-#include <config.h>
+#include <xmms-sid.h>
+
+/*
+ * Constants
+ */
+#define XS_CONFIG_IDENT		"XMMS-SID"	/* Configuration file identifier */
+#define XS_CONFIG_FILE		"/.xmms/config"
+
 
 /*
  * Configuration structure
  */
-enum XMMS_SID_CHN {
-	XMMS_SID_CHN_MONO = 0,
-	XMMS_SID_CHN_STEREO,
-	XMMS_SID_CHN_AUTOPAN
+enum XS_RES {
+	XS_RES_8BIT = 8,
+	XS_RES_16BIT = 16,
+	XS_RES_24BIT = 24
+};
+
+enum XS_CHN {
+	XS_CHN_MONO = 1,
+	XS_CHN_STEREO = 2,
+	XS_CHN_AUTOPAN = 3
 };
 
 
-enum XMMS_SID_CLOCK {
-	XMMS_SID_CLOCK_PAL = 1,
-	XMMS_SID_CLOCK_NTSC
+enum XS_CLOCK {
+	XS_CLOCK_PAL = 1,
+	XS_CLOCK_NTSC
 };
 
 
-enum XMMS_SID_MPU {
-	XMMS_SID_MPU_BANK_SWITCHING = 1,
-	XMMS_SID_MPU_TRANSPARENT_ROM,
-	XMMS_SID_MPU_PLAYSID_ENVIRONMENT
+enum XS_EMUENGINE {
+	XS_SIDPLAY1 = 1,
+	XS_SIDPLAY2
 };
 
 
-enum XMMS_SID_PMETHOD {
-	XMMS_SID_PMETHOD_NONE = 0,
-	XMMS_SID_PMETHOD_MAXSILENCE,
-	XMMS_SID_PMETHOD_DATABASE
+enum XS_MPU {
+	XS_MPU_BANK_SWITCHING = 1,
+	XS_MPU_TRANSPARENT_ROM,
+	XS_MPU_PLAYSID_ENVIRONMENT
 };
 
 
 extern struct t_xs_cfg {
-	gint fmtBitsPerSample;
-	gint fmtChannels;
-	gint fmtFrequency;
-
-	gboolean muffledOutput;
-	gboolean addStaticNoise;
-
-
-	gboolean mos8580;
-	gboolean emulateFilter;
-	gfloat filterFs;
-	gfloat filterFm;
-	gfloat filterFt;
-	gint memoryMode;
-	gint clockSpeed;
-	gboolean forceSpeed;
+	/* General audio settings */
+	gint		fmtBitsPerSample;
+	gint		fmtChannels;
+	gint		fmtFrequency;
 
 
-	gboolean playUseMaxTime;
-	gint playMaxTime;
-	gint playMethod;
-	gint playMaxSilentTime;
-	gint playSilentPercent;
-	gchar *playDBPath;
+	/* General libSIDPlay settings */
+	gboolean	mos8580;		/* TRUE = 8580, FALSE = 6581 */
+	gboolean	emulateFilters;
+	gfloat		filterFs;
+	gfloat		filterFm;
+	gfloat		filterFt;
+	gint		memoryMode;
+	gint		clockSpeed;		/* PAL (50Hz) or NTSC (60Hz) */
+	gboolean	forceSpeed;		/* TRUE = force to given clockspeed */
+
+	gboolean	oversampleEnable;	/* TRUE = oversample */
+	gint		oversampleFactor;	/* Factor of oversampling */
 
 
-	gboolean useSTIL;
-	gchar *STILpath;
-
-	gboolean finfoUseColors;
-	gboolean detectMagic;
+	/* Playing settings */
+	gboolean	playMaxTimeEnable;	/* TRUE = use MAX playtime */
+	gint		playMaxTime;		/* MAX playtime in seconds */
+	gboolean	songlenDBEnable;
+	gchar		*songlenDBPath;
 
 
-	gboolean titleOverride;
-	gchar *titleFormat;
+	/* Miscellaneous settings */
+	gboolean	stilDBEnable;
+	gchar		*stilDBPath;
+
+	gboolean	detectMagic;
+
+	gboolean	titleOverride;
+	gchar		*titleFormat;
 } xs_cfg;
 
 
@@ -98,7 +110,8 @@
  * Functions
  */
 void	xs_configure(void);
-void	xs_get_configure(void);
+void	xs_read_configuration(void);
+gint	xs_write_configuration(void);
 
 
 #ifdef __cplusplus
--- a/src/xs_fileinfo.cc	Thu Jun 19 20:49:01 2003 +0000
+++ b/src/xs_fileinfo.cc	Thu Jun 19 22:38:01 2003 +0000
@@ -3,8 +3,7 @@
 
    SIDTune file information dialog
    
-   Written by Matti "ccr" Hamalainen <mhamalai@ratol.fi>
-   (Interface created with Glade, the Gtk+ interface builder)
+   Written by Matti "ccr" Hamalainen <ccr@tnsp.org>
 
    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
--- a/src/xs_genui.c	Thu Jun 19 20:49:01 2003 +0000
+++ b/src/xs_genui.c	Thu Jun 19 22:38:01 2003 +0000
@@ -9,85 +9,35 @@
 #include "xs_glade.h"
 
 
-void cfg_filt_reset_clicked(GtkButton * button, gpointer user_data)
-{
-
-}
-
-
-void cfg_sld_dbbrowse_clicked(GtkButton * button, gpointer user_data)
+void
+fileinfo_sub_tune_clicked              (GtkButton       *button,
+                                        gpointer         user_data)
 {
 
 }
 
 
-void cfg_stil_browse_clicked(GtkButton * button, gpointer user_data)
-{
-
-}
-
-
-void cfg_ok_clicked(GtkButton * button, gpointer user_data)
-{
-
-}
-
-
-void cfg_cancel_clicked(GtkButton * button, gpointer user_data)
-{
-
-}
-
-
-void about_ok_clicked(GtkButton * button, gpointer user_data)
+void
+fileinfo_ok_clicked                    (GtkButton       *button,
+                                        gpointer         user_data)
 {
 
 }
 
 
-void fileinfo_sub_tune_clicked(GtkButton * button, gpointer user_data)
-{
-
-}
-
-
-void fileinfo_ok_clicked(GtkButton * button, gpointer user_data)
-{
-
-}
-
-
-void ctrl_song_prev(GtkButton * button, gpointer user_data)
+void
+ctrl_song_prev                         (GtkButton       *button,
+                                        gpointer         user_data)
 {
 
 }
 
 
-void ctrl_song_next(GtkButton * button, gpointer user_data)
-{
-
-}
-
-
-void songlensel_ok_button_clicked(GtkButton * button, gpointer user_data)
+void
+ctrl_song_next                         (GtkButton       *button,
+                                        gpointer         user_data)
 {
 
 }
 
 
-void songlensel_cancel_button_clicked(GtkButton * button, gpointer user_data)
-{
-
-}
-
-
-void stilsel_ok_button_clicked(GtkButton * button, gpointer user_data)
-{
-
-}
-
-
-void stilsel_cancel_button_clicked(GtkButton * button, gpointer user_data)
-{
-
-}
--- a/src/xs_genui.h	Thu Jun 19 20:49:01 2003 +0000
+++ b/src/xs_genui.h	Thu Jun 19 22:38:01 2003 +0000
@@ -2,27 +2,27 @@
 
 
 void
-cfg_filt_reset_clicked                 (GtkButton       *button,
+xs_cfg_filter_reset                    (GtkButton       *button,
                                         gpointer         user_data);
 
 void
-cfg_sld_dbbrowse_clicked               (GtkButton       *button,
+xs_cfg_sld_dbbrowse                    (GtkButton       *button,
                                         gpointer         user_data);
 
 void
-cfg_stil_browse_clicked                (GtkButton       *button,
+xs_cfg_stil_browse                     (GtkButton       *button,
                                         gpointer         user_data);
 
 void
-cfg_ok_clicked                         (GtkButton       *button,
+xs_cfg_ok                              (GtkButton       *button,
                                         gpointer         user_data);
 
 void
-cfg_cancel_clicked                     (GtkButton       *button,
+xs_cfg_cancel                          (GtkButton       *button,
                                         gpointer         user_data);
 
 void
-about_ok_clicked                       (GtkButton       *button,
+xs_about_ok                            (GtkButton       *button,
                                         gpointer         user_data);
 
 void
@@ -42,17 +42,17 @@
                                         gpointer         user_data);
 
 void
-songlensel_ok_button_clicked           (GtkButton       *button,
+xs_cfg_sldb_fs_ok                      (GtkButton       *button,
                                         gpointer         user_data);
 
 void
-songlensel_cancel_button_clicked       (GtkButton       *button,
+xs_cfg_sldb_fs_cancel                  (GtkButton       *button,
                                         gpointer         user_data);
 
 void
-stilsel_ok_button_clicked              (GtkButton       *button,
+xs_cfg_stil_fs_ok                      (GtkButton       *button,
                                         gpointer         user_data);
 
 void
-stilsel_cancel_button_clicked          (GtkButton       *button,
+xs_cfg_stil_fs_cancel                  (GtkButton       *button,
                                         gpointer         user_data);
--- a/src/xs_init.c	Thu Jun 19 20:49:01 2003 +0000
+++ b/src/xs_init.c	Thu Jun 19 22:38:01 2003 +0000
@@ -29,7 +29,7 @@
 	NULL,			/* FILLED BY XMMS */
 	PACKAGE_STRING,		/* Plugin description */
 	xs_init,		/* Initialization */
-	xs_aboutbox,		/* Show aboutbox */
+	xs_about,		/* Show aboutbox */
 	xs_configure,		/* Show/edit configuration */
 	xs_is_our_file,		/* Check file */
 	NULL,			/* Scan directory */
--- a/src/xs_length.c	Thu Jun 19 20:49:01 2003 +0000
+++ b/src/xs_length.c	Thu Jun 19 22:38:01 2003 +0000
@@ -571,16 +571,12 @@
 		if (dbEntry)
 			{
 			if ((subTune >= 0) && (subTune < dbEntry->nLengths))
-				iResult = dbEntry->sLengths[subTune];
+				iResult = dbEntry->sLengths[subTune - 1];
   			}
   		}
 	}
 
- /* Check for max playtime */
- if ((iResult == -1) && xs_cfg.playMaxTimeEnable)
-	iResult = xs_cfg.playMaxTime;
- 
- XSDEBUG("fname='%s', sub=%i, res=%i\n", fileName, subTune, iResult);
+// XSDEBUG("fname='%s', sub=%i, res=%i\n", fileName, subTune, iResult);
   
  return iResult;
 }
--- a/src/xs_stil.c	Thu Jun 19 20:49:01 2003 +0000
+++ b/src/xs_stil.c	Thu Jun 19 22:38:01 2003 +0000
@@ -3,7 +3,7 @@
 
    STIL-database parsing functions
    
-   Mostly written by Matti "ccr" Hamalainen <mhamalai@ratol.fi>,
+   Mostly written by Matti "ccr" Hamalainen <ccr@tnsp.org>,
    some parts written by Willem Monsuwe <willem@stack.nl>
 
    This program is free software; you can redistribute it and/or modify
--- a/src/xs_support.c	Thu Jun 19 20:49:01 2003 +0000
+++ b/src/xs_support.c	Thu Jun 19 22:38:01 2003 +0000
@@ -35,7 +35,7 @@
  
  /* Allocate memory for destination */
  *ppcResult = (gchar *) g_realloc(*ppcResult, strlen(pcStr) + 1);
- if (*ppResult == NULL) return -1;
+ if (*ppcResult == NULL) return -1;
 
  /* Copy to the destination */
  strcpy(*ppcResult, pcStr);