Mercurial > hg > xmms-sid

changeset 751:55eea3fa8868

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Rename some structures.
author Matti Hamalainen <ccr@tnsp.org>
date Mon, 05 Nov 2012 18:42:57 +0200
parents 3180bf22090f
children 64e7e427a436
files src/xmms-sid.c src/xmms-sid.h src/xs_fileinfo.c src/xs_length.c src/xs_length.h src/xs_player.c src/xs_player.h src/xs_sidplay.h src/xs_sidplay1.cc src/xs_sidplay1.h src/xs_sidplay2.cc src/xs_sidplay2.h src/xs_slsup.c src/xs_slsup.h src/xs_stil.c src/xs_stil.h src/xs_support.c src/xs_support.h src/xs_title.c src/xs_title.h
diffstat 20 files changed, 165 insertions(+), 165 deletions(-) [+]
line wrap: on
line diff
--- a/src/xmms-sid.c	Mon Nov 05 17:53:22 2012 +0200
+++ b/src/xmms-sid.c	Mon Nov 05 18:42:57 2012 +0200
@@ -44,7 +44,7 @@
 /*
  * Global variables
  */
-xs_status_t xs_status;
+XSEngineState xs_status;
 XS_MUTEX(xs_status);
 static XS_THREAD_T xs_decode_thread;
 
@@ -190,7 +190,7 @@
 
     /* Try to detect via detection routine, if required */
     if (xs_cfg.detectMagic) {
-        xs_file_t *f;
+        XSFile *f;
         if ((f = xs_fopen(filename, "rb")) != NULL) {
             if (xs_status.sidPlayer->plrProbe(f))
                 return TRUE;
@@ -228,8 +228,8 @@
  */
 void *xs_playthread(void *argPointer)
 {
-    xs_status_t myStatus;
-    xs_tuneinfo_t *myTune;
+    XSEngineState myStatus;
+    XSTuneInfo *myTune;
     gboolean audioOpen = FALSE, doPlay = FALSE, isFound = FALSE;
     gint audioGot, songLength, i;
     gchar *audioBuffer = NULL, *tmpTitle;
@@ -239,7 +239,7 @@
     /* Initialize */
     XSDEBUG("entering player thread\n");
     XS_MUTEX_LOCK(xs_status);
-    memcpy(&myStatus, &xs_status, sizeof(xs_status_t));
+    memcpy(&myStatus, &xs_status, sizeof(XSEngineState));
     myTune = xs_status.tuneInfo;
     for (i = 0; i <= myTune->nsubTunes; i++)
         myTune->subTunes[i].tunePlayed = FALSE;
@@ -826,7 +826,7 @@
  */
 void xs_get_song_info(gchar * songFilename, gchar ** songTitle, gint * songLength)
 {
-    xs_tuneinfo_t *info;
+    XSTuneInfo *info;
     
     XS_MUTEX_LOCK(xs_status);
 
--- a/src/xmms-sid.h	Mon Nov 05 17:53:22 2012 +0200
+++ b/src/xmms-sid.h	Mon Nov 05 18:42:57 2012 +0200
@@ -137,7 +137,7 @@
     gint        tuneSpeed,
             tuneLength;
     gboolean    tunePlayed;
-} xs_subtuneinfo_t;
+} XSSubTuneInfo;
 
 
 typedef struct {
@@ -152,8 +152,8 @@
             dataFileLen,
             sidModel;
     gint        nsubTunes, startTune;
-    xs_subtuneinfo_t    *subTunes;
-} xs_tuneinfo_t;
+    XSSubTuneInfo    *subTunes;
+} XSTuneInfo;
 
 
 /* Global variables
--- a/src/xs_fileinfo.c	Mon Nov 05 17:53:22 2012 +0200
+++ b/src/xs_fileinfo.c	Mon Nov 05 18:42:57 2012 +0200
@@ -33,7 +33,7 @@
 
 
 static GtkWidget *xs_fileinfowin = NULL;
-static stil_node_t *xs_fileinfostil = NULL;
+static XSSTILNode *xs_fileinfostil = NULL;
 XS_MUTEX(xs_fileinfowin);
 
 #define LUW(x)    lookup_widget(xs_fileinfowin, x)
@@ -120,7 +120,7 @@
 
 static void xs_fileinfo_subtune(GtkWidget * widget, void *data)
 {
-    stil_subnode_t *tmpNode;
+    XSSTILSubNode *tmpNode;
     GtkWidget *tmpText;
     gchar *subName, *subAuthor, *subInfo;
 
@@ -136,7 +136,7 @@
 #endif
 
     /* Get subtune information */
-    tmpNode = (stil_subnode_t *) data;
+    tmpNode = (XSSTILSubNode *) data;
     if (!tmpNode && xs_fileinfostil)
         tmpNode = xs_fileinfostil->subTunes[0];
     
@@ -170,8 +170,8 @@
 void xs_fileinfo(gchar * filename)
 {
     GtkWidget *tmpMenuItem, *tmpMenu, *tmpOptionMenu;
-    xs_tuneinfo_t *tmpInfo;
-    stil_subnode_t *tmpNode;
+    XSTuneInfo *tmpInfo;
+    XSSTILSubNode *tmpNode;
     gchar tmpStr[256], *tmpFilename;
     gint n;
 
--- a/src/xs_length.c	Mon Nov 05 17:53:22 2012 +0200
+++ b/src/xs_length.c	Mon Nov 05 18:42:57 2012 +0200
@@ -30,7 +30,7 @@
 
 /* Free memory allocated for given SLDB node
  */
-static void xs_sldb_node_free(sldb_node_t *node)
+static void xs_sldb_node_free(XSSLDBNode *node)
 {
     if (node) {
         /* Nothing much to do here ... */
@@ -42,7 +42,7 @@
 
 /* Insert given node to db linked list
  */
-static void xs_sldb_node_insert(xs_sldb_t *db, sldb_node_t *node)
+static void xs_sldb_node_insert(XSSLDB *db, XSSLDBNode *node)
 {
     assert(db);
 
@@ -100,15 +100,15 @@
 
 /* Parse one SLDB definition line, return SLDB node
  */
-sldb_node_t * xs_sldb_read_entry(gchar *inLine)
+XSSLDBNode * xs_sldb_read_entry(gchar *inLine)
 {
     size_t linePos;
     gint i;
     gboolean isOK;
-    sldb_node_t *tmnode;
+    XSSLDBNode *tmnode;
 
     /* Allocate new node */
-    tmnode = (sldb_node_t *) g_malloc0(sizeof(sldb_node_t));
+    tmnode = (XSSLDBNode *) g_malloc0(sizeof(XSSLDBNode));
     if (!tmnode) {
         xs_error("Error allocating new node. Fatal error.\n");
         return NULL;
@@ -191,12 +191,12 @@
 
 /* Read database to memory
  */
-gint xs_sldb_read(xs_sldb_t *db, const gchar *dbFilename)
+gint xs_sldb_read(XSSLDB *db, const gchar *dbFilename)
 {
     FILE *inFile;
     gchar inLine[XS_BUF_SIZE];
     size_t lineNum;
-    sldb_node_t *tmnode;
+    XSSLDBNode *tmnode;
     assert(db);
 
     /* Try to open the file */
@@ -269,16 +269,16 @@
 {
     /* We assume here that we never ever get NULL-pointers or similar */
     return xs_sldb_cmphash(
-        (*(sldb_node_t **) node1)->md5Hash,
-        (*(sldb_node_t **) node2)->md5Hash);
+        (*(XSSLDBNode **) node1)->md5Hash,
+        (*(XSSLDBNode **) node2)->md5Hash);
 }
 
 
 /* (Re)create index
  */
-gint xs_sldb_index(xs_sldb_t * db)
+gint xs_sldb_index(XSSLDB * db)
 {
-    sldb_node_t *pCurr;
+    XSSLDBNode *pCurr;
     size_t i;
     assert(db);
 
@@ -299,7 +299,7 @@
     /* Check number of nodes */
     if (db->n > 0) {
         /* Allocate memory for index-table */
-        db->pindex = (sldb_node_t **) g_malloc(sizeof(sldb_node_t *) * db->n);
+        db->pindex = (XSSLDBNode **) g_malloc(sizeof(XSSLDBNode *) * db->n);
         if (!db->pindex)
             return -1;
 
@@ -312,7 +312,7 @@
         }
 
         /* Sort the indexes */
-        qsort(db->pindex, db->n, sizeof(sldb_node_t *), xs_sldb_cmp);
+        qsort(db->pindex, db->n, sizeof(XSSLDBNode *), xs_sldb_cmp);
     }
 
     return 0;
@@ -321,9 +321,9 @@
 
 /* Free a given song-length database
  */
-void xs_sldb_free(xs_sldb_t * db)
+void xs_sldb_free(XSSLDB * db)
 {
-    sldb_node_t *pCurr, *next;
+    XSSLDBNode *pCurr, *next;
 
     if (!db)
         return;
@@ -377,7 +377,7 @@
 
 static gint xs_get_sid_hash(const gchar *filename, xs_md5hash_t hash)
 {
-    xs_file_t *inFile;
+    XSFile *inFile;
     xs_md5state_t inState;
     psidv1_header_t psidH;
     psidv2_header_t psidH2;
@@ -494,9 +494,9 @@
 
 /* Get node from db index via binary search
  */
-sldb_node_t *xs_sldb_get(xs_sldb_t *db, const gchar *filename)
+XSSLDBNode *xs_sldb_get(XSSLDB *db, const gchar *filename)
 {
-    sldb_node_t keyItem, *key, **item;
+    XSSLDBNode keyItem, *key, **item;
 
     /* Check the database pointers */
     if (!db || !db->nodes || !db->pindex)
--- a/src/xs_length.h	Mon Nov 05 17:53:22 2012 +0200
+++ b/src/xs_length.h	Mon Nov 05 18:42:57 2012 +0200
@@ -21,27 +21,27 @@
 
 /* Types
  */
-typedef struct _sldb_node_t {
+typedef struct _XSSLDBNode {
     xs_md5hash_t    md5Hash;    /* 128-bit MD5 hash-digest */
     gint            nlengths;   /* Number of lengths */
     gint            *lengths;   /* Lengths in seconds */
-    struct _sldb_node_t *prev, *next;
-} sldb_node_t;
+    struct _XSSLDBNode *prev, *next;
+} XSSLDBNode;
 
 
 typedef struct {
-    sldb_node_t     *nodes,
+    XSSLDBNode     *nodes,
                     **pindex;
     size_t          n;
-} xs_sldb_t;
+} XSSLDB;
 
 
 /* Functions
  */
-gint            xs_sldb_read(xs_sldb_t *, const gchar *);
-gint            xs_sldb_index(xs_sldb_t *);
-void            xs_sldb_free(xs_sldb_t *);
-sldb_node_t *   xs_sldb_get(xs_sldb_t *, const gchar *);
+gint            xs_sldb_read(XSSLDB *, const gchar *);
+gint            xs_sldb_index(XSSLDB *);
+void            xs_sldb_free(XSSLDB *);
+XSSLDBNode *   xs_sldb_get(XSSLDB *, const gchar *);
 
 #ifdef __cplusplus
 }
--- a/src/xs_player.c	Mon Nov 05 17:53:22 2012 +0200
+++ b/src/xs_player.c	Mon Nov 05 18:42:57 2012 +0200
@@ -10,7 +10,7 @@
 
 /* List of emulator engines
  */
-static const xs_engine_t xs_enginelist[] = {
+static const XSEngine xs_enginelist[] = {
 #ifdef HAVE_SIDPLAY1
     {XS_ENG_SIDPLAY1,
      xs_sidplay1_probe,
@@ -36,7 +36,7 @@
 static const gint xs_nenginelist = (sizeof(xs_enginelist) / sizeof(xs_enginelist[0]));
 
 
-gboolean xs_init_emu_engine(int *configured, xs_status_t *status)
+gboolean xs_init_emu_engine(int *configured, XSEngineState *status)
 {
     gint engine;
     gboolean initialized;
@@ -49,7 +49,7 @@
         if (xs_enginelist[engine].plrIdent == *configured) {
             if (xs_enginelist[engine].plrInit(status)) {
                 initialized = TRUE;
-                status->sidPlayer = (xs_engine_t *) & xs_enginelist[engine];
+                status->sidPlayer = (XSEngine *) & xs_enginelist[engine];
             }
         }
         engine++;
@@ -61,7 +61,7 @@
     while (engine < xs_nenginelist && !initialized) {
         if (xs_enginelist[engine].plrInit(status)) {
             initialized = TRUE;
-            status->sidPlayer = (xs_engine_t *) &xs_enginelist[engine];
+            status->sidPlayer = (XSEngine *) &xs_enginelist[engine];
             *configured = xs_enginelist[engine].plrIdent;
         } else
             engine++;
--- a/src/xs_player.h	Mon Nov 05 17:53:22 2012 +0200
+++ b/src/xs_player.h	Mon Nov 05 18:42:57 2012 +0200
@@ -8,49 +8,49 @@
 extern "C" {
 #endif
 
-struct xs_status_t;
+struct XSEngineState;
 
 typedef struct {
     gint        plrIdent;
-    gboolean    (*plrProbe)(xs_file_t *);
-    gboolean    (*plrInit)(struct xs_status_t *);
-    void        (*plrClose)(struct xs_status_t *);
-    gboolean    (*plrInitSong)(struct xs_status_t *);
-    guint       (*plrFillBuffer)(struct xs_status_t *, gchar *, guint);
-    gboolean    (*plrLoadSID)(struct xs_status_t *, gchar *);
-    void        (*plrDeleteSID)(struct xs_status_t *);
-    xs_tuneinfo_t*    (*plrGetSIDInfo)(const gchar *);
-    gboolean    (*plrUpdateSIDInfo)(struct xs_status_t *);
-    void        (*plrFlush)(struct xs_status_t *);
-} xs_engine_t;
+    gboolean    (*plrProbe)(XSFile *);
+    gboolean    (*plrInit)(struct XSEngineState *);
+    void        (*plrClose)(struct XSEngineState *);
+    gboolean    (*plrInitSong)(struct XSEngineState *);
+    guint       (*plrFillBuffer)(struct XSEngineState *, gchar *, guint);
+    gboolean    (*plrLoadSID)(struct XSEngineState *, gchar *);
+    void        (*plrDeleteSID)(struct XSEngineState *);
+    XSTuneInfo*    (*plrGetSIDInfo)(const gchar *);
+    gboolean    (*plrUpdateSIDInfo)(struct XSEngineState *);
+    void        (*plrFlush)(struct XSEngineState *);
+} XSEngine;
 
 
-typedef struct xs_status_t {
+typedef struct XSEngineState {
     gint        audioFrequency,     /* Audio settings */
                 audioChannels,
                 audioBitsPerSample;
     AFormat     audioFormat;
 
     void        *sidEngine;         /* SID-emulation internal engine data */
-    xs_engine_t *sidPlayer;         /* Selected player engine */
+    XSEngine *sidPlayer;         /* Selected player engine */
     gboolean    isError,
                 isPlaying,
                 isInitialized;
     gint        currSong,           /* Current sub-tune */
                 lastTime;
 
-    xs_tuneinfo_t *tuneInfo;
-} xs_status_t;
+    XSTuneInfo *tuneInfo;
+} XSEngineState;
 
 
 /* Global variables
  */
 extern InputPlugin    xs_plugin_ip;
 
-extern xs_status_t    xs_status;
+extern XSEngineState    xs_status;
 XS_MUTEX_H(xs_status);
 
-gboolean xs_init_emu_engine(int *configured, xs_status_t *status);
+gboolean xs_init_emu_engine(int *configured, XSEngineState *status);
 
 #ifdef __cplusplus
 }
--- a/src/xs_sidplay.h	Mon Nov 05 17:53:22 2012 +0200
+++ b/src/xs_sidplay.h	Mon Nov 05 18:42:57 2012 +0200
@@ -26,9 +26,9 @@
  * (those variables that are only set by libSIDPlay when tune is initialized).
  * Rest of the information is acquired in TFUNCTION2()
  */
-xs_tuneinfo_t *TFUNCTION(const gchar *sidFilename)
+XSTuneInfo *TFUNCTION(const gchar *sidFilename)
 {
-    xs_tuneinfo_t *pResult;
+    XSTuneInfo *pResult;
     TTUNEINFO myInfo;
     TTUNE *myTune;
     guint8 *buf = NULL;
@@ -88,12 +88,12 @@
 
 /* Updates the information of currently playing tune
  */
-gboolean TFUNCTION2(xs_status_t *myStatus)
+gboolean TFUNCTION2(XSEngineState *myStatus)
 {
     TTUNEINFO myInfo;
     TTUNE *myTune;
     TENGINE *myEngine;
-    xs_tuneinfo_t *i;
+    XSTuneInfo *i;
     
     /* Check if we have required structures initialized */
     if (!myStatus || !myStatus->tuneInfo || !myStatus->sidEngine)
--- a/src/xs_sidplay1.cc	Mon Nov 05 17:53:22 2012 +0200
+++ b/src/xs_sidplay1.cc	Mon Nov 05 18:42:57 2012 +0200
@@ -62,7 +62,7 @@
 
 /* Check if we can play the given file
  */
-gboolean xs_sidplay1_probe(xs_file_t *f)
+gboolean xs_sidplay1_probe(XSFile *f)
 {
     gchar tmpBuf[4];
     
@@ -80,7 +80,7 @@
 
 /* Initialize SIDPlay1
  */
-gboolean xs_sidplay1_init(xs_status_t * myStatus)
+gboolean xs_sidplay1_init(XSEngineState * myStatus)
 {
     gint tmpFreq;
     xs_sidplay1_t *myEngine;
@@ -244,7 +244,7 @@
 
 /* Close SIDPlay1 engine
  */
-void xs_sidplay1_close(xs_status_t * myStatus)
+void xs_sidplay1_close(XSEngineState * myStatus)
 {
     xs_sidplay1_t *myEngine;
     assert(myStatus);
@@ -271,7 +271,7 @@
 
 /* Initialize current song and sub-tune
  */
-gboolean xs_sidplay1_initsong(xs_status_t * myStatus)
+gboolean xs_sidplay1_initsong(XSEngineState * myStatus)
 {
     xs_sidplay1_t *myEngine;
     assert(myStatus);
@@ -297,7 +297,7 @@
 
 /* Emulate and render audio data to given buffer
  */
-guint xs_sidplay1_fillbuffer(xs_status_t * myStatus, gchar * audioBuffer, guint audioBufSize)
+guint xs_sidplay1_fillbuffer(XSEngineState * myStatus, gchar * audioBuffer, guint audioBufSize)
 {
     xs_sidplay1_t *myEngine;
     assert(myStatus);
@@ -313,7 +313,7 @@
 
 /* Load a given SID-tune file
  */
-gboolean xs_sidplay1_load(xs_status_t * myStatus, gchar * filename)
+gboolean xs_sidplay1_load(XSEngineState * myStatus, gchar * filename)
 {
     xs_sidplay1_t *myEngine;
     assert(myStatus);
@@ -337,7 +337,7 @@
 
 /* Delete INTERNAL information
  */
-void xs_sidplay1_delete(xs_status_t * myStatus)
+void xs_sidplay1_delete(XSEngineState * myStatus)
 {
     xs_sidplay1_t *myEngine;
     assert(myStatus);
--- a/src/xs_sidplay1.h	Mon Nov 05 17:53:22 2012 +0200
+++ b/src/xs_sidplay1.h	Mon Nov 05 18:42:57 2012 +0200
@@ -9,15 +9,15 @@
 extern "C" {
 #endif
 
-gboolean    xs_sidplay1_probe(xs_file_t *);
-void        xs_sidplay1_close(xs_status_t *);
-gboolean    xs_sidplay1_init(xs_status_t *);
-gboolean    xs_sidplay1_initsong(xs_status_t *);
-guint        xs_sidplay1_fillbuffer(xs_status_t *, gchar *, guint);
-gboolean    xs_sidplay1_load(xs_status_t *, gchar *);
-void        xs_sidplay1_delete(xs_status_t *);
-xs_tuneinfo_t*    xs_sidplay1_getinfo(const gchar *);
-gboolean    xs_sidplay1_updateinfo(xs_status_t *);
+gboolean    xs_sidplay1_probe(XSFile *);
+void        xs_sidplay1_close(XSEngineState *);
+gboolean    xs_sidplay1_init(XSEngineState *);
+gboolean    xs_sidplay1_initsong(XSEngineState *);
+guint        xs_sidplay1_fillbuffer(XSEngineState *, gchar *, guint);
+gboolean    xs_sidplay1_load(XSEngineState *, gchar *);
+void        xs_sidplay1_delete(XSEngineState *);
+XSTuneInfo*    xs_sidplay1_getinfo(const gchar *);
+gboolean    xs_sidplay1_updateinfo(XSEngineState *);
 
 #ifdef __cplusplus
 }
--- a/src/xs_sidplay2.cc	Mon Nov 05 17:53:22 2012 +0200
+++ b/src/xs_sidplay2.cc	Mon Nov 05 18:42:57 2012 +0200
@@ -103,7 +103,7 @@
 
 /* Check if we can play the given file
  */
-gboolean xs_sidplay2_probe(xs_file_t *f)
+gboolean xs_sidplay2_probe(XSFile *f)
 {
     gchar tmpBuf[5];
     
@@ -121,7 +121,7 @@
 
 /* Initialize SIDPlay2
  */
-gboolean xs_sidplay2_init(xs_status_t * myStatus)
+gboolean xs_sidplay2_init(XSEngineState * myStatus)
 {
     gint i;
     xs_sidplay2_t *myEngine;
@@ -430,7 +430,7 @@
 
 /* Close SIDPlay2 engine
  */
-void xs_sidplay2_close(xs_status_t * myStatus)
+void xs_sidplay2_close(XSEngineState * myStatus)
 {
     xs_sidplay2_t *myEngine;
     assert(myStatus);
@@ -466,7 +466,7 @@
 
 /* Initialize current song and sub-tune
  */
-gboolean xs_sidplay2_initsong(xs_status_t * myStatus)
+gboolean xs_sidplay2_initsong(XSEngineState * myStatus)
 {
     xs_sidplay2_t *myEngine;
     assert(myStatus);
@@ -492,7 +492,7 @@
 
 /* Emulate and render audio data to given buffer
  */
-guint xs_sidplay2_fillbuffer(xs_status_t * myStatus, gchar * audioBuffer, guint audioBufSize)
+guint xs_sidplay2_fillbuffer(XSEngineState * myStatus, gchar * audioBuffer, guint audioBufSize)
 {
     xs_sidplay2_t *myEngine;
     assert(myStatus);
@@ -506,7 +506,7 @@
 
 /* Load a given SID-tune file
  */
-gboolean xs_sidplay2_load(xs_status_t * myStatus, gchar * pcFilename)
+gboolean xs_sidplay2_load(XSEngineState * myStatus, gchar * pcFilename)
 {
     xs_sidplay2_t *myEngine;
     assert(myStatus);
@@ -530,7 +530,7 @@
 
 /* Delete INTERNAL information
  */
-void xs_sidplay2_delete(xs_status_t * myStatus)
+void xs_sidplay2_delete(XSEngineState * myStatus)
 {
     xs_sidplay2_t *myEngine;
     assert(myStatus);
@@ -546,7 +546,7 @@
 
 /* Hardware backend flushing
  */
-void xs_sidplay2_flush(xs_status_t * myStatus)
+void xs_sidplay2_flush(XSEngineState * myStatus)
 {
     assert(myStatus);
 
--- a/src/xs_sidplay2.h	Mon Nov 05 17:53:22 2012 +0200
+++ b/src/xs_sidplay2.h	Mon Nov 05 18:42:57 2012 +0200
@@ -9,16 +9,16 @@
 extern "C" {
 #endif
 
-gboolean    xs_sidplay2_probe(xs_file_t *);
-void        xs_sidplay2_close(xs_status_t *);
-gboolean    xs_sidplay2_init(xs_status_t *);
-gboolean    xs_sidplay2_initsong(xs_status_t *);
-guint        xs_sidplay2_fillbuffer(xs_status_t *, gchar *, guint);
-gboolean    xs_sidplay2_load(xs_status_t *, gchar *);
-void        xs_sidplay2_delete(xs_status_t *);
-xs_tuneinfo_t*    xs_sidplay2_getinfo(const gchar *);
-gboolean    xs_sidplay2_updateinfo(xs_status_t *);
-void        xs_sidplay2_flush(xs_status_t *);
+gboolean    xs_sidplay2_probe(XSFile *);
+void        xs_sidplay2_close(XSEngineState *);
+gboolean    xs_sidplay2_init(XSEngineState *);
+gboolean    xs_sidplay2_initsong(XSEngineState *);
+guint        xs_sidplay2_fillbuffer(XSEngineState *, gchar *, guint);
+gboolean    xs_sidplay2_load(XSEngineState *, gchar *);
+void        xs_sidplay2_delete(XSEngineState *);
+XSTuneInfo*    xs_sidplay2_getinfo(const gchar *);
+gboolean    xs_sidplay2_updateinfo(XSEngineState *);
+void        xs_sidplay2_flush(XSEngineState *);
 
 #ifdef __cplusplus
 }
--- a/src/xs_slsup.c	Mon Nov 05 17:53:22 2012 +0200
+++ b/src/xs_slsup.c	Mon Nov 05 18:42:57 2012 +0200
@@ -24,10 +24,10 @@
 #include "xs_config.h"
 
 
-static xs_sldb_t *xs_sldb_db = NULL;
+static XSSLDB *xs_sldb_db = NULL;
 XS_MUTEX(xs_sldb_db);
 
-static xs_stildb_t *xs_stildb_db = NULL;
+static XSSTILDB *xs_stildb_db = NULL;
 XS_MUTEX(xs_stildb_db);
 
 
@@ -49,7 +49,7 @@
         xs_stildb_free(xs_stildb_db);
 
     /* Allocate database */
-    xs_stildb_db = (xs_stildb_t *) g_malloc0(sizeof(xs_stildb_t));
+    xs_stildb_db = (XSSTILDB *) g_malloc0(sizeof(XSSTILDB));
     if (!xs_stildb_db) {
         XS_MUTEX_UNLOCK(xs_cfg);
         XS_MUTEX_UNLOCK(xs_stildb_db);
@@ -89,9 +89,9 @@
 }
 
 
-stil_node_t *xs_stil_get(gchar *filename)
+XSSTILNode *xs_stil_get(gchar *filename)
 {
-    stil_node_t *result;
+    XSSTILNode *result;
     gchar *tmpFilename;
 
     XS_MUTEX_LOCK(xs_stildb_db);
@@ -142,7 +142,7 @@
         xs_sldb_free(xs_sldb_db);
 
     /* Allocate database */
-    xs_sldb_db = (xs_sldb_t *) g_malloc0(sizeof(xs_sldb_t));
+    xs_sldb_db = (XSSLDB *) g_malloc0(sizeof(XSSLDB));
     if (!xs_sldb_db) {
         XS_MUTEX_UNLOCK(xs_cfg);
         XS_MUTEX_UNLOCK(xs_sldb_db);
@@ -182,9 +182,9 @@
 }
 
 
-sldb_node_t *xs_songlen_get(const gchar * filename)
+XSSLDBNode *xs_songlen_get(const gchar * filename)
 {
-    sldb_node_t *result;
+    XSSLDBNode *result;
 
     XS_MUTEX_LOCK(xs_sldb_db);
 
@@ -201,18 +201,18 @@
 
 /* Allocate a new tune information structure
  */
-xs_tuneinfo_t *xs_tuneinfo_new(const gchar * filename,
+XSTuneInfo *xs_tuneinfo_new(const gchar * filename,
         gint nsubTunes, gint startTune, const gchar * sidName,
         const gchar * sidComposer, const gchar * sidCopyright,
         gint loadAddr, gint initAddr, gint playAddr,
         gint dataFileLen, const gchar *sidFormat, gint sidModel)
 {
-    xs_tuneinfo_t *result;
-    sldb_node_t *tmpLength;
+    XSTuneInfo *result;
+    XSSLDBNode *tmpLength;
     gint i;
 
     /* Allocate structure */
-    result = (xs_tuneinfo_t *) g_malloc0(sizeof(xs_tuneinfo_t));
+    result = (XSTuneInfo *) g_malloc0(sizeof(XSTuneInfo));
     if (!result) {
         xs_error("Could not allocate memory for tuneinfo ('%s')\n",
             filename);
@@ -228,7 +228,7 @@
     }
 
     /* Allocate space for subtune information */
-    result->subTunes = g_malloc0(sizeof(xs_subtuneinfo_t) * (nsubTunes + 1));
+    result->subTunes = g_malloc0(sizeof(XSSubTuneInfo) * (nsubTunes + 1));
     if (!result->subTunes) {
         xs_error("Could not allocate memory for subtuneinfo ('%s', %i)\n",
             filename, nsubTunes);
@@ -273,7 +273,7 @@
 
 /* Free given tune information structure
  */
-void xs_tuneinfo_free(xs_tuneinfo_t * tune)
+void xs_tuneinfo_free(XSTuneInfo * tune)
 {
     if (!tune) return;
 
--- a/src/xs_slsup.h	Mon Nov 05 17:53:22 2012 +0200
+++ b/src/xs_slsup.h	Mon Nov 05 18:42:57 2012 +0200
@@ -11,18 +11,18 @@
 
 gint        xs_stil_init(void);
 void        xs_stil_close(void);
-stil_node_t *xs_stil_get(gchar *filename);
+XSSTILNode *xs_stil_get(gchar *filename);
 
 gint        xs_songlen_init(void);
 void        xs_songlen_close(void);
-sldb_node_t *xs_songlen_get(const gchar *);
+XSSLDBNode *xs_songlen_get(const gchar *);
 
-xs_tuneinfo_t *xs_tuneinfo_new(const gchar * pcFilename,
+XSTuneInfo *xs_tuneinfo_new(const gchar * pcFilename,
             gint nsubTunes, gint startTune, const gchar * sidName,
             const gchar * sidComposer, const gchar * sidCopyright,
             gint loadAddr, gint initAddr, gint playAddr,
             gint dataFileLen, const gchar *sidFormat, gint sidModel);
-void        xs_tuneinfo_free(xs_tuneinfo_t *);
+void        xs_tuneinfo_free(XSTuneInfo *);
 
 
 #ifdef __cplusplus
--- a/src/xs_stil.c	Mon Nov 05 17:53:22 2012 +0200
+++ b/src/xs_stil.c	Mon Nov 05 18:42:57 2012 +0200
@@ -30,7 +30,7 @@
 
 /* Database handling functions
  */
-static gboolean xs_stildb_node_realloc(stil_node_t *node, gint nsubTunes)
+static gboolean xs_stildb_node_realloc(XSSTILNode *node, gint nsubTunes)
 {
     if (!node) return FALSE;
 
@@ -39,8 +39,8 @@
         gint clearIndex, clearLength;
         
         node->subTunes =
-            (stil_subnode_t **) g_realloc(node->subTunes,
-            (nsubTunes + 1) * sizeof(stil_subnode_t **));
+            (XSSTILSubNode **) g_realloc(node->subTunes,
+            (nsubTunes + 1) * sizeof(XSSTILSubNode **));
 
         if (!node->subTunes) {
             xs_error("SubTune pointer structure realloc failed.\n");
@@ -55,15 +55,15 @@
             clearIndex = node->nsubTunes + 1;
             clearLength = (nsubTunes - clearIndex + 1);
         }
-        memset(&(node->subTunes[clearIndex]), 0, clearLength * sizeof(stil_subnode_t **));
+        memset(&(node->subTunes[clearIndex]), 0, clearLength * sizeof(XSSTILSubNode **));
         
         node->nsubTunes = nsubTunes;
     }
 
     /* Allocate memory for subTune */
     if (!node->subTunes[nsubTunes]) {
-        node->subTunes[nsubTunes] = (stil_subnode_t *)
-            g_malloc0(sizeof(stil_subnode_t));
+        node->subTunes[nsubTunes] = (XSSTILSubNode *)
+            g_malloc0(sizeof(XSSTILSubNode));
         
         if (!node->subTunes[nsubTunes]) {
             xs_error("SubTune structure malloc failed!\n");
@@ -75,10 +75,10 @@
 }
 
 
-static void xs_stildb_node_free(stil_node_t *node)
+static void xs_stildb_node_free(XSSTILNode *node)
 {
     gint i;
-    stil_subnode_t *subnode;
+    XSSTILSubNode *subnode;
 
     if (!node) return;
 
@@ -99,12 +99,12 @@
 }
 
 
-static stil_node_t *xs_stildb_node_new(gchar *filename)
+static XSSTILNode *xs_stildb_node_new(gchar *filename)
 {
-    stil_node_t *result;
+    XSSTILNode *result;
 
     /* Allocate memory for new node */
-    result = (stil_node_t *) g_malloc0(sizeof(stil_node_t));
+    result = (XSSTILNode *) g_malloc0(sizeof(XSSTILNode));
     if (!result)
         return NULL;
 
@@ -121,7 +121,7 @@
 
 /* Insert given node to db linked list
  */
-static void xs_stildb_node_insert(xs_stildb_t *db, stil_node_t *node)
+static void xs_stildb_node_insert(XSSTILDB *db, XSSTILNode *node)
 {
     assert(db != NULL);
 
@@ -158,12 +158,12 @@
     fprintf(stderr, "#%d: '%s'\n", lineNum, inLine);
 }
 
-gint xs_stildb_read(xs_stildb_t *db, gchar *dbFilename)
+gint xs_stildb_read(XSSTILDB *db, gchar *dbFilename)
 {
     FILE *inFile;
     gchar inLine[XS_BUF_SIZE + 16];    /* Since we add some chars here and there */
     size_t lineNum;
-    stil_node_t *tmnode;
+    XSSTILNode *tmnode;
     gboolean isError, isMulti;
     gint subEntry;
     gchar *tmpLine = inLine;
@@ -330,16 +330,16 @@
 {
     /* We assume here that we never ever get NULL-pointers or similar */
     return strcmp(
-        (*(stil_node_t **) node1)->filename,
-        (*(stil_node_t **) node2)->filename);
+        (*(XSSTILNode **) node1)->filename,
+        (*(XSSTILNode **) node2)->filename);
 }
 
 
 /* (Re)create index
  */
-gint xs_stildb_index(xs_stildb_t *db)
+gint xs_stildb_index(XSSTILDB *db)
 {
-    stil_node_t *curr;
+    XSSTILNode *curr;
     size_t i;
 
     /* Free old index */
@@ -359,7 +359,7 @@
     /* Check number of nodes */
     if (db->n > 0) {
         /* Allocate memory for index-table */
-        db->pindex = (stil_node_t **) g_malloc(sizeof(stil_node_t *) * db->n);
+        db->pindex = (XSSTILNode **) g_malloc(sizeof(XSSTILNode *) * db->n);
         if (!db->pindex)
             return -1;
 
@@ -372,7 +372,7 @@
         }
 
         /* Sort the indexes */
-        qsort(db->pindex, db->n, sizeof(stil_node_t *), xs_stildb_cmp);
+        qsort(db->pindex, db->n, sizeof(XSSTILNode *), xs_stildb_cmp);
     }
 
     return 0;
@@ -381,9 +381,9 @@
 
 /* Free a given STIL database
  */
-void xs_stildb_free(xs_stildb_t *db)
+void xs_stildb_free(XSSTILDB *db)
 {
-    stil_node_t *curr, *next;
+    XSSTILNode *curr, *next;
 
     if (!db)
         return;
@@ -412,9 +412,9 @@
 
 /* Get STIL information node from database
  */
-stil_node_t *xs_stildb_get_node(xs_stildb_t *db, gchar *filename)
+XSSTILNode *xs_stildb_get_node(XSSTILDB *db, gchar *filename)
 {
-    stil_node_t keyItem, *key, **item;
+    XSSTILNode keyItem, *key, **item;
 
     /* Check the database pointers */
     if (!db || !db->nodes || !db->pindex)
@@ -423,7 +423,7 @@
     /* Look-up index using binary search */
     keyItem.filename = filename;
     key = &keyItem;
-    item = bsearch(&key, db->pindex, db->n, sizeof(stil_node_t *), xs_stildb_cmp);
+    item = bsearch(&key, db->pindex, db->n, sizeof(XSSTILNode *), xs_stildb_cmp);
     if (item)
         return *item;
     else
--- a/src/xs_stil.h	Mon Nov 05 17:53:22 2012 +0200
+++ b/src/xs_stil.h	Mon Nov 05 18:42:57 2012 +0200
@@ -14,30 +14,30 @@
           *author,
           *title,
           *info;
-} stil_subnode_t;
+} XSSTILSubNode;
 
 
-typedef struct _stil_node_t {
+typedef struct _XSSTILNode {
     gchar               *filename;
     gint                nsubTunes;
-    stil_subnode_t      **subTunes;
-    struct _stil_node_t *prev, *next;
-} stil_node_t;
+    XSSTILSubNode      **subTunes;
+    struct _XSSTILNode *prev, *next;
+} XSSTILNode;
 
 
 typedef struct {
-    stil_node_t *nodes,
+    XSSTILNode *nodes,
                 **pindex;
     size_t      n;
-} xs_stildb_t;
+} XSSTILDB;
 
 
 /* Functions
  */
-gint            xs_stildb_read(xs_stildb_t *, gchar *);
-gint            xs_stildb_index(xs_stildb_t *);
-void            xs_stildb_free(xs_stildb_t *);
-stil_node_t *   xs_stildb_get_node(xs_stildb_t *, gchar *);
+gint            xs_stildb_read(XSSTILDB *, gchar *);
+gint            xs_stildb_index(XSSTILDB *);
+void            xs_stildb_free(XSSTILDB *);
+XSSTILNode *   xs_stildb_get_node(XSSTILDB *, gchar *);
 
 #ifdef __cplusplus
 }
--- a/src/xs_support.c	Mon Nov 05 17:53:22 2012 +0200
+++ b/src/xs_support.c	Mon Nov 05 18:42:57 2012 +0200
@@ -24,13 +24,13 @@
 #include <ctype.h>
 
 
-guint16 xs_fread_be16(xs_file_t *f)
+guint16 xs_fread_be16(XSFile *f)
 {
     return (((guint16) xs_fgetc(f)) << 8) | ((guint16) xs_fgetc(f));
 }
 
 
-guint32 xs_fread_be32(xs_file_t *f)
+guint32 xs_fread_be32(XSFile *f)
 {
     return (((guint32) xs_fgetc(f)) << 24) |
         (((guint32) xs_fgetc(f)) << 16) |
@@ -43,7 +43,7 @@
  */
 gint xs_fload_buffer(const gchar *filename, guint8 **buf, size_t *bufSize)
 {
-    xs_file_t *f;
+    XSFile *f;
     glong seekPos;
     
     /* Open file, get file size */
--- a/src/xs_support.h	Mon Nov 05 17:53:22 2012 +0200
+++ b/src/xs_support.h	Mon Nov 05 18:42:57 2012 +0200
@@ -66,7 +66,7 @@
 /* VFS replacement functions
  */
 #ifdef __AUDACIOUS_NEWVFS__
-#define xs_file_t VFSFile
+#define XSFile VFSFile
 #define xs_fopen(a,b) aud_vfs_fopen(a,b)
 #define xs_fclose(a) aud_vfs_fclose(a)
 #define xs_fgetc(a) aud_vfs_getc(a)
@@ -76,7 +76,7 @@
 #define xs_ftell(a) aud_vfs_ftell(a)
 #define xs_fseek(a,b,c) aud_vfs_fseek(a,b,c)
 #else
-#define xs_file_t FILE
+#define XSFile FILE
 #define xs_fopen(a,b) fopen(a,b)
 #define xs_fclose(a) fclose(a)
 #define xs_fgetc(a) fgetc(a)
@@ -86,8 +86,8 @@
 #define xs_ftell(a) ftell(a)
 #define xs_fseek(a,b,c) fseek(a,b,c)
 #endif
-guint16 xs_fread_be16(xs_file_t *);
-guint32 xs_fread_be32(xs_file_t *);
+guint16 xs_fread_be16(XSFile *);
+guint32 xs_fread_be32(XSFile *);
 gint    xs_fload_buffer(const gchar *, guint8 **, size_t *);
 
 
--- a/src/xs_title.c	Mon Nov 05 17:53:22 2012 +0200
+++ b/src/xs_title.c	Mon Nov 05 18:42:57 2012 +0200
@@ -65,11 +65,11 @@
 }
 
 
-gchar *xs_make_titlestring(xs_tuneinfo_t *p, gint subTune)
+gchar *xs_make_titlestring(XSTuneInfo *p, gint subTune)
 {
     gchar *tmpFilename, *tmpFilePath, *tmpFileExt,
         *str, *result, tmpStr[XS_BUF_SIZE], tmpBuf[XS_BUF_SIZE];
-    xs_subtuneinfo_t *subInfo;
+    XSSubTuneInfo *subInfo;
     gint index;
 
     /* Get filename parts */
--- a/src/xs_title.h	Mon Nov 05 17:53:22 2012 +0200
+++ b/src/xs_title.h	Mon Nov 05 18:42:57 2012 +0200
@@ -7,7 +7,7 @@
 extern "C" {
 #endif
 
-gchar *xs_make_titlestring(xs_tuneinfo_t *, gint);
+gchar *xs_make_titlestring(XSTuneInfo *, gint);
 
 #ifdef __cplusplus
 }