--- a/src/xmms-sid.c	Sun Dec 19 16:57:01 2004 +0000
+++ b/src/xmms-sid.c	Tue Dec 21 09:25:03 2004 +0000
@@ -62,22 +62,6 @@
 
 
 /*
- * Structure defining methods/functions of each player
- */
-typedef struct {
-	gint		plrIdent;
-	gboolean	(*plrIsOurFile)(gchar *);
-	gboolean	(*plrInit)(t_xs_status *);
-	void		(*plrClose)(t_xs_status *);
-	gboolean	(*plrInitSong)(t_xs_status *);
-	guint		(*plrFillBuffer)(t_xs_status *, gchar *, guint);
-	gboolean	(*plrLoadSID)(t_xs_status *, gchar *);
-	void		(*plrDeleteSID)(t_xs_status *);
-	t_xs_tune*	(*plrGetSIDInfo)(gchar *);
-} t_xs_player;
-
-
-/*
  * List of players and links to their functions
  */
 t_xs_player xs_playerlist[] = {
@@ -107,23 +91,20 @@
 /*
  * Global variables
  */
-struct t_xs_cfg			xs_cfg;
-t_xs_status			xs_status;
-t_xs_player			*xs_player	= NULL;
-static pthread_t		xs_decode_thread;
-static pthread_mutex_t		xs_mutex	= PTHREAD_MUTEX_INITIALIZER;
-static GtkWidget		*xs_subctrl	= NULL;
-static GtkObject		*xs_subctrl_adj = NULL;
-static t_xs_tune		*xs_fileinfotune = NULL;
-static t_xs_stil_node		*xs_fileinfostil = NULL;
+t_xs_status		xs_status;
+XS_MUTEX(xs_status);
+static pthread_t	xs_decode_thread;
 
+static GtkWidget	*xs_subctrl	= NULL;
+static GtkObject	*xs_subctrl_adj = NULL;
+XS_MUTEX(xs_subctrl);
 
 void	xs_subctrl_close(void);
 void	xs_subctrl_update(void);
 
 
 /*
- * Re-initialize some settings
+ * Initialization functions
  */
 void xs_reinit(void)
 {
@@ -153,7 +134,7 @@
  		if (xs_playerlist[iPlayer].plrInit(&xs_status))
  			{
  			isInitialized = TRUE;
- 			xs_player = (t_xs_player *) &xs_playerlist[iPlayer];
+ 			xs_status.sidPlayer = (t_xs_player *) &xs_playerlist[iPlayer];
  			}
  		}
 	iPlayer++;
@@ -167,7 +148,7 @@
 	if (xs_playerlist[iPlayer].plrInit(&xs_status))
 		{
 		isInitialized = TRUE;
-		xs_player = (t_xs_player *) &xs_playerlist[iPlayer];
+		xs_status.sidPlayer = (t_xs_player *) &xs_playerlist[iPlayer];
  		} else
  		iPlayer++;
  	}
@@ -176,14 +157,14 @@
 
  /* Initialize song-length database */
  xs_songlen_close();
- if (xs_cfg.songlenDBEnable && (xs_songlen_init() < 0))
+ if (xs_cfg.songlenDBEnable && (xs_songlen_init() != 0))
  	{
 	XSERR("Error initializing song-length database!\n");
 	}
 	
  /* Initialize STIL database */
  xs_stil_close();
- if (xs_cfg.stilDBEnable && (xs_stil_init() < 0))
+ if (xs_cfg.stilDBEnable && (xs_stil_init() != 0))
  	{
  	XSERR("Error initializing STIL database!\n");
  	}
@@ -218,11 +199,11 @@
  /* Stop playing, free structures */
  xs_stop();
 
- xs_tune_free(xs_status.pTune);
- xs_status.pTune = NULL;
+ xs_tuneinfo_free(xs_status.tuneInfo);
+ xs_status.tuneInfo = NULL;
  
- xs_player->plrDeleteSID(&xs_status);
- xs_player->plrClose(&xs_status);
+ xs_status.sidPlayer->plrDeleteSID(&xs_status);
+ xs_status.sidPlayer->plrClose(&xs_status);
 
  xs_songlen_close();
  xs_stil_close();
@@ -237,14 +218,14 @@
 gint xs_is_our_file(gchar *pcFilename)
 {
  gchar *pcExt;
- assert(xs_player);
+ assert(xs_status.sidPlayer);
 
  /* Check the filename */
  if (pcFilename == NULL)
 	return FALSE;
 
  /* Try to detect via detection routine, if required */
- if (xs_cfg.detectMagic && xs_player->plrIsOurFile(pcFilename))
+ if (xs_cfg.detectMagic && xs_status.sidPlayer->plrIsOurFile(pcFilename))
  	return TRUE;
 
  /* Detect just by checking filename extension */
@@ -274,18 +255,18 @@
 void *xs_play_loop(void *argPointer)
 {
  t_xs_status myStatus;
- t_xs_tune *myTune;
+ t_xs_tuneinfo *myTune;
  gboolean audioOpen = FALSE, doPlay = FALSE;
  guint audioGot;
  gint songLength;
  gchar audioBuffer[XS_BUFSIZE];
 
  /* Initialize */
- pthread_mutex_lock(&xs_mutex);
- XSDEBUG("entering play thread\n");
+ XSDEBUG("entering player thread\n");
+ XS_MUTEX_LOCK(xs_status);
  memcpy(&myStatus, &xs_status, sizeof(t_xs_status));
- myTune = xs_status.pTune;
- pthread_mutex_unlock(&xs_mutex);
+ myTune = xs_status.tuneInfo;
+ XS_MUTEX_UNLOCK(xs_status);
 
 
  /*
@@ -294,27 +275,31 @@
  doPlay = TRUE;
  while (xs_status.isPlaying && doPlay)
  {
- pthread_mutex_lock(&xs_mutex);
+ XS_MUTEX_LOCK(xs_status);
  myStatus.currSong = xs_status.currSong;
- pthread_mutex_unlock(&xs_mutex);
+ XS_MUTEX_UNLOCK(xs_status);
+ XS_MUTEX_LOCK(xs_subctrl);
  xs_subctrl_update();
+ XS_MUTEX_UNLOCK(xs_subctrl);
 
  XSDEBUG("subtune #%i selected, initializing...\n", myStatus.currSong);
 
  songLength = myTune->subTunes[myStatus.currSong - 1].tuneLength;
  
  /* Check minimum playtime */
+ XS_MUTEX_LOCK(xs_cfg);
  if (xs_cfg.playMinTimeEnable)
  	{
 	if (songLength < xs_cfg.playMinTime)
 		songLength = xs_cfg.playMinTime;
 	}
+ XS_MUTEX_UNLOCK(xs_cfg);
 
  /* Initialize song */
- if (!xs_player->plrInitSong(&myStatus))
+ if (!myStatus.sidPlayer->plrInitSong(&myStatus))
 	{
 	XSERR("Couldn't initialize SID-tune '%s' (sub-tune #%i)!\n",
-		myTune->tuneFilename, myStatus.currSong);
+		myTune->sidFilename, myStatus.currSong);
 	goto xs_err_exit;
 	}
 
@@ -333,9 +318,10 @@
 	{
 	XSERR("Couldn't open XMMS audio output (fmt=%x, freq=%i, nchan=%i)!\n",
 	myStatus.audioFormat, myStatus.audioFrequency, myStatus.audioChannels);
-	pthread_mutex_lock(&xs_mutex);
+	
+	XS_MUTEX_LOCK(xs_status);
 	xs_status.isError = TRUE;
-	pthread_mutex_unlock(&xs_mutex);
+	XS_MUTEX_UNLOCK(xs_status);
 	goto xs_err_exit;
 	}
 
@@ -347,7 +333,7 @@
  while (xs_status.isPlaying && myStatus.isPlaying && (xs_status.currSong == myStatus.currSong))
 	{
 	/* Render audio data */
-	audioGot = xs_player->plrFillBuffer(&myStatus, audioBuffer, XS_BUFSIZE);
+	audioGot = myStatus.sidPlayer->plrFillBuffer(&myStatus, audioBuffer, XS_BUFSIZE);
 
 	/* I <3 visualice/haujobb */
 	xs_plugin_ip.add_vis_pcm(
@@ -366,6 +352,7 @@
 		xs_plugin_ip.output->write_audio(audioBuffer, audioGot);
 
 	/* Check if we have played enough */
+	XS_MUTEX_LOCK(xs_cfg);
 	if (xs_cfg.playMaxTimeEnable)
 		{
 		if (xs_cfg.playMaxTimeUnknown)
@@ -378,6 +365,7 @@
 				myStatus.isPlaying = FALSE;
 			}
 		}
+	XS_MUTEX_UNLOCK(xs_cfg);
 
 	if (songLength > 0)
 		{
@@ -411,9 +399,9 @@
  /* Exit the playing thread */
  XSDEBUG("exiting thread, bye.\n");
 
- pthread_mutex_lock(&xs_mutex);
+ XS_MUTEX_LOCK(xs_status);
  xs_status.isPlaying = FALSE;
- pthread_mutex_unlock(&xs_mutex);
+ XS_MUTEX_UNLOCK(xs_status);
  pthread_exit(NULL);
 }
 
@@ -426,17 +414,19 @@
  */
 void xs_play_file(gchar *pcFilename)
 {
+ assert(xs_status.sidPlayer);
+
  XSDEBUG("play '%s'\n", pcFilename);
  
  /* Get tune information */
- if ((xs_status.pTune = xs_player->plrGetSIDInfo(pcFilename)) == NULL)
+ if ((xs_status.tuneInfo = xs_status.sidPlayer->plrGetSIDInfo(pcFilename)) == NULL)
  	return;
 
  /* Initialize the tune */
- if (!xs_player->plrLoadSID(&xs_status, pcFilename))
+ if (!xs_status.sidPlayer->plrLoadSID(&xs_status, pcFilename))
  	{
- 	xs_tune_free(xs_status.pTune);
- 	xs_status.pTune = NULL;
+ 	xs_tuneinfo_free(xs_status.tuneInfo);
+ 	xs_status.tuneInfo = NULL;
  	return;
  	}
 
@@ -445,15 +435,15 @@
  /* Set general status information */
  xs_status.isPlaying	= TRUE;
  xs_status.isError	= FALSE;
- xs_status.currSong	= xs_status.pTune->startTune;
+ xs_status.currSong	= xs_status.tuneInfo->startTune;
  
  /* Start the playing thread! */
  if (pthread_create(&xs_decode_thread, NULL, xs_play_loop, NULL) < 0)
 	{
 	XSERR("Couldn't start playing thread! Possible reason reported by system: %s\n", strerror(errno));
- 	xs_tune_free(xs_status.pTune);
-	xs_status.pTune = NULL;
-	xs_player->plrDeleteSID(&xs_status);
+ 	xs_tuneinfo_free(xs_status.tuneInfo);
+	xs_status.tuneInfo = NULL;
+	xs_status.sidPlayer->plrDeleteSID(&xs_status);
 	}
 
  XSDEBUG("systems should be up?\n");
@@ -479,16 +469,16 @@
 	{
 	/* Stop playing */
 	XSDEBUG("stopping...\n");
-	pthread_mutex_lock(&xs_mutex);
+	XS_MUTEX_LOCK(xs_status);
 	xs_status.isPlaying = FALSE;
-	pthread_mutex_unlock(&xs_mutex);
+	XS_MUTEX_UNLOCK(xs_status);
 	pthread_join(xs_decode_thread, NULL);
 	}
 
  /* Free tune information */
- xs_player->plrDeleteSID(&xs_status);
- xs_tune_free(xs_status.pTune);
- xs_status.pTune = NULL;
+ xs_status.sidPlayer->plrDeleteSID(&xs_status);
+ xs_tuneinfo_free(xs_status.tuneInfo);
+ xs_status.tuneInfo = NULL;
 
  /* Update subtune control */
  xs_subctrl_update();
@@ -506,104 +496,100 @@
 
 
 /*
+ * Set or change sub-tune
+ */
+void xs_set_subtune(int n)
+{
+ XS_MUTEX_LOCK(xs_status);
+ 
+ if (xs_status.tuneInfo && xs_status.isPlaying)
+ 	{
+ 	if ((n >= 1) && (n <= xs_status.tuneInfo->nsubTunes))
+ 		xs_status.currSong = n;
+	}
+
+ XS_MUTEX_UNLOCK(xs_status);
+
+ xs_subctrl_update();
+}
+
+
+void xs_change_subtune(int n)
+{
+ XS_MUTEX_LOCK(xs_status);
+ 
+ if (xs_status.tuneInfo && xs_status.isPlaying)
+ 	{
+ 	n += xs_status.currSong;
+ 	
+ 	if ((n >= 1) && (n <= xs_status.tuneInfo->nsubTunes))
+ 		xs_status.currSong = n;
+	}
+
+ XS_MUTEX_UNLOCK(xs_status);
+
+ xs_subctrl_update();
+}
+
+
+/*
  * Pop-up subtune selector
  */
-#define LUW(x...)	lookup_widget(xs_fileinfowin, ## x)
+void xs_subctrl_setsong(void)
+{
+ xs_set_subtune(GTK_ADJUSTMENT(xs_subctrl_adj)->value);
+}
+
+
+void xs_subctrl_prevsong(void)
+{
+ xs_change_subtune(-1);
+}
+
+
+void xs_subctrl_nextsong(void)
+{
+ xs_change_subtune( 1);
+}
+
 
 void xs_subctrl_update(void)
 {
  GtkAdjustment *tmpAdj;
  gboolean isEnabled;
  
+ XS_MUTEX_LOCK(xs_status);
+ 
  /* Check if control window exists, we are currently playing and have a tune */
  if (xs_subctrl)
 	{
-	if (xs_status.pTune && xs_status.isPlaying)
+	if (xs_status.tuneInfo && xs_status.isPlaying)
 		{
+		XS_MUTEX_LOCK(xs_subctrl);
 	 	tmpAdj = GTK_ADJUSTMENT(xs_subctrl_adj);
  	
  		tmpAdj->value = xs_status.currSong;
  		tmpAdj->lower = 1;
-		tmpAdj->upper = xs_status.pTune->nsubTunes;
+		tmpAdj->upper = xs_status.tuneInfo->nsubTunes;
  		gtk_adjustment_value_changed(tmpAdj);
+ 		XS_MUTEX_UNLOCK(xs_subctrl);
  		} else
  		xs_subctrl_close();
  	}
 
- if (xs_fileinfowin)
- 	{
- 	/* Check if we are currently playing and have a tune */
- 	if (xs_status.pTune && xs_status.isPlaying && (xs_status.pTune->nsubTunes > 1))
- 		{
-		tmpAdj = gtk_range_get_adjustment(GTK_RANGE(LUW("fileinfo_subctrl_adj")));
-
- 		tmpAdj->value = xs_status.currSong;
- 		tmpAdj->lower = 1;
-		tmpAdj->upper = xs_status.pTune->nsubTunes;
- 		gtk_adjustment_value_changed(tmpAdj);
- 		isEnabled = TRUE; 		
- 		} else
- 		isEnabled = FALSE;
-	
-	/* Enable or disable subtune-control in fileinfo window */
-	gtk_widget_set_sensitive(LUW("fileinfo_subctrl_prev"), isEnabled);
-	gtk_widget_set_sensitive(LUW("fileinfo_subctrl_adj"), isEnabled);
-	gtk_widget_set_sensitive(LUW("fileinfo_subctrl_next"), isEnabled);
-	}
-}
-
-
-void xs_fileinfo_setsong(void)
-{
- pthread_mutex_lock(&xs_mutex);
- xs_status.currSong = gtk_range_get_adjustment(GTK_RANGE(LUW("fileinfo_subctrl_adj")))->value;
- pthread_mutex_unlock(&xs_mutex);
-}
-
-
-void xs_subctrl_setsong(void)
-{
- pthread_mutex_lock(&xs_mutex);
- xs_status.currSong = GTK_ADJUSTMENT(xs_subctrl_adj)->value;
- pthread_mutex_unlock(&xs_mutex);
-}
-
-
-void xs_subctrl_prevsong(void)
-{
- if (xs_status.pTune && xs_status.isPlaying)
- 	{
- 	pthread_mutex_lock(&xs_mutex);
- 	if (xs_status.currSong > 1)
-		xs_status.currSong--;
-	pthread_mutex_unlock(&xs_mutex);
-	}
-
- xs_subctrl_update();
-}
-
-
-void xs_subctrl_nextsong(void)
-{
- if (xs_status.pTune && xs_status.isPlaying)
- 	{
- 	pthread_mutex_lock(&xs_mutex);
- 	if (xs_status.currSong < xs_status.pTune->nsubTunes)
-		xs_status.currSong++;
-	pthread_mutex_unlock(&xs_mutex);
-	}
-
- xs_subctrl_update();
+ XS_MUTEX_UNLOCK(xs_status);
 }
 
 
 void xs_subctrl_close(void)
 {
+ XS_MUTEX_LOCK(xs_subctrl);
  if (xs_subctrl)
  	{
 	gtk_widget_destroy(xs_subctrl);
 	xs_subctrl = NULL;
 	}
+ XS_MUTEX_UNLOCK(xs_subctrl);
 }
 
 
@@ -620,8 +606,14 @@
 {
  GtkWidget *frame25, *hbox15, *subctrl_prev, *subctrl_current, *subctrl_next;
 
- if (!xs_status.pTune || !xs_status.isPlaying ||
-    xs_subctrl || (xs_status.pTune->nsubTunes <= 1)) return;
+ XS_MUTEX_LOCK(xs_subctrl);
+ 
+ if (!xs_status.tuneInfo || !xs_status.isPlaying ||
+    xs_subctrl || (xs_status.tuneInfo->nsubTunes <= 1))
+    {
+    XS_MUTEX_UNLOCK(xs_subctrl);
+    return;
+    }
 
  /* Create the pop-up window */
  xs_subctrl = gtk_window_new (GTK_WINDOW_DIALOG);
@@ -656,7 +648,7 @@
  gtk_widget_set_name (subctrl_prev, "subctrl_prev");
  gtk_box_pack_start (GTK_BOX (hbox15), subctrl_prev, FALSE, FALSE, 0);
 
- xs_subctrl_adj = gtk_adjustment_new (xs_status.currSong, 1, xs_status.pTune->nsubTunes, 1, 1, 0);
+ xs_subctrl_adj = gtk_adjustment_new (xs_status.currSong, 1, xs_status.tuneInfo->nsubTunes, 1, 1, 0);
  gtk_signal_connect (GTK_OBJECT (xs_subctrl_adj), "value_changed",
 	GTK_SIGNAL_FUNC (xs_subctrl_setsong), NULL);
 
@@ -681,6 +673,8 @@
  	GTK_SIGNAL_FUNC (xs_subctrl_keypress), NULL);
  
  gtk_widget_show_all(xs_subctrl);
+
+ XS_MUTEX_UNLOCK(xs_subctrl);
 }
 
 
@@ -696,16 +690,22 @@
 void xs_seek(gint iTime)
 {
  /* Check status */
- if (!xs_status.pTune || !xs_status.isPlaying) return;
+ XS_MUTEX_LOCK(xs_status);
+ if (!xs_status.tuneInfo || !xs_status.isPlaying)
+ 	{
+ 	XS_MUTEX_UNLOCK(xs_status);
+ 	return;
+ 	}
 
- /* Act according to settings */ 
+ /* Act according to settings */
+ XS_MUTEX_LOCK(xs_cfg); 
  switch (xs_cfg.subsongControl) {
  case XS_SSC_SEEK:
 	if (iTime < xs_status.lastTime)
-		xs_subctrl_prevsong();
+		xs_change_subtune(-1);
 		else
 	if (iTime > xs_status.lastTime)
-		xs_subctrl_nextsong();
+		xs_change_subtune(1);
 	break;
 
  case XS_SSC_POPUP:
@@ -715,18 +715,14 @@
  /* If we have song-position patch, check settings */
 #ifdef HAVE_SONG_POSITION
  case XS_SSC_PATCH:
-	pthread_mutex_lock(&xs_mutex);
-
-	if ((iTime > 0) && (iTime <= xs_status.pTune->nsubTunes))
+	if ((iTime > 0) && (iTime <= xs_status.tuneInfo->nsubTunes))
 		xs_status.currSong = iTime;
-	
-	pthread_mutex_unlock(&xs_mutex);
 	break;
 #endif
+ }
 
- default:
- 	break;
- }
+ XS_MUTEX_UNLOCK(xs_cfg);
+ XS_MUTEX_UNLOCK(xs_status);
 }
 
 
@@ -740,18 +736,30 @@
 gint xs_get_time(void)
 {
  /* If errorflag is set, return -2 to signal it to XMMS's idle callback */
+ XS_MUTEX_LOCK(xs_status);
+ 
  if (xs_status.isError)
+ 	{
+ 	XS_MUTEX_UNLOCK(xs_status);
 	return -2;
+	}
 
  /* If there is no tune, return -1 */
- if (!xs_status.pTune)
+ if (!xs_status.tuneInfo)
+ 	{
+ 	XS_MUTEX_UNLOCK(xs_status);
  	return -1;
+ 	}
  
  /* If tune has ended, return -1 */
  if (!xs_status.isPlaying)
+ 	{
+ 	XS_MUTEX_UNLOCK(xs_status);
 	return -1;
+	}
 
  /* Let's see what we do */
+ XS_MUTEX_LOCK(xs_cfg);
  switch (xs_cfg.subsongControl) {
  case XS_SSC_SEEK:
  	xs_status.lastTime = (xs_plugin_ip.output->output_time() / 1000);
@@ -759,13 +767,14 @@
  
 #ifdef HAVE_SONG_POSITION
  case XS_SSC_PATCH:
-	pthread_mutex_lock(&xs_mutex);
-	set_song_position(xs_status.currSong, 1, xs_status.pTune->nsubTunes);
-	pthread_mutex_unlock(&xs_mutex);
+	set_song_position(xs_status.currSong, 1, xs_status.tuneInfo->nsubTunes);
 	break;
 #endif
  }
  
+ XS_MUTEX_UNLOCK(xs_cfg);
+ XS_MUTEX_UNLOCK(xs_status);
+
  /* Return output time reported by audio output plugin */
  return xs_plugin_ip.output->output_time();
 }
@@ -779,11 +788,11 @@
  */
 void xs_get_song_info(gchar *songFilename, gchar **songTitle, gint *songLength)
 {
- t_xs_tune *pInfo;
+ t_xs_tuneinfo *pInfo;
  gint tmpInt;
  
  /* Get tune information from emulation engine */
- pInfo = xs_player->plrGetSIDInfo(songFilename);
+ pInfo = xs_status.sidPlayer->plrGetSIDInfo(songFilename);
  if (!pInfo) return;
 
  /* Get sub-tune information, if available */
@@ -799,50 +808,54 @@
 	}
 
  /* Free tune information */	
- xs_tune_free(pInfo);
+ xs_tuneinfo_free(pInfo);
 }
 
 
-/*
- * Allocate a new tune structure
+/* Allocate a new tune information structure
  */
-t_xs_tune *xs_tune_new(gchar *pcFilename, gint nsubTunes, gint startTune,
-	gchar *tuneName, gchar *tuneComposer, gchar *tuneCopyright)
+t_xs_tuneinfo *xs_tuneinfo_new(gchar *pcFilename, gint nsubTunes, gint startTune,
+	gchar *sidName, gchar *sidComposer, gchar *sidCopyright,
+	gint loadAddr, gint initAddr, gint playAddr, gint dataFileLen)
 {
- t_xs_tune *pResult;
+ t_xs_tuneinfo *pResult;
  
- pResult = (t_xs_tune *) g_malloc0(sizeof(t_xs_tune));
+ pResult = (t_xs_tuneinfo *) g_malloc0(sizeof(t_xs_tuneinfo));
  if (!pResult) return NULL;
  
- pResult->tuneFilename = g_strdup(pcFilename);
- if (!pResult->tuneFilename)
+ pResult->sidFilename = g_strdup(pcFilename);
+ if (!pResult->sidFilename)
  	{
  	g_free(pResult);
  	return NULL;
  	}
  
- pResult->tuneName	= g_strdup(tuneName);
- pResult->tuneComposer	= g_strdup(tuneComposer);
- pResult->tuneCopyright	= g_strdup(tuneCopyright);
+ pResult->sidName	= g_strdup(sidName);
+ pResult->sidComposer	= g_strdup(sidComposer);
+ pResult->sidCopyright	= g_strdup(sidCopyright);
  pResult->nsubTunes	= nsubTunes;
  pResult->startTune	= startTune;
+
+ pResult->loadAddr	= loadAddr;
+ pResult->initAddr	= initAddr;
+ pResult->playAddr	= playAddr;
+ pResult->dataFileLen	= dataFileLen;
  
  return pResult;
 }
 
 
-/*
- * Free tune information
+/* Free given tune information structure
  */
-void xs_tune_free(t_xs_tune *pTune)
+void xs_tuneinfo_free(t_xs_tuneinfo *pTune)
 {
  gint i;
  if (!pTune) return;
 
- g_free(pTune->tuneFilename);	pTune->tuneFilename = NULL;
- g_free(pTune->tuneName);	pTune->tuneName = NULL;
- g_free(pTune->tuneComposer);	pTune->tuneComposer = NULL;
- g_free(pTune->tuneCopyright);	pTune->tuneCopyright = NULL;
+ g_free(pTune->sidFilename);	pTune->sidFilename = NULL;
+ g_free(pTune->sidName);	pTune->sidName = NULL;
+ g_free(pTune->sidComposer);	pTune->sidComposer = NULL;
+ g_free(pTune->sidCopyright);	pTune->sidCopyright = NULL;
  
  for (i = 0; i < pTune->nsubTunes; i++)
  	{
@@ -856,3 +869,7 @@
  g_free(pTune);
 }
 
+
+void xs_fileinfo_ok(void)
+{
+}