Mercurial > hg > xmms-sid

changeset 754:5557837fe5b6

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Rename some more variables.
author Matti Hamalainen <ccr@tnsp.org>
date Mon, 05 Nov 2012 18:52:10 +0200
parents 36c6a6e629bb
children 762ef85ead1a
files src/xs_sidplay1.cc src/xs_sidplay2.cc
diffstat 2 files changed, 211 insertions(+), 211 deletions(-) [+]
line wrap: on
line diff
--- a/src/xs_sidplay1.cc	Mon Nov 05 18:51:11 2012 +0200
+++ b/src/xs_sidplay1.cc	Mon Nov 05 18:52:10 2012 +0200
@@ -80,58 +80,58 @@
 
 /* Initialize SIDPlay1
  */
-gboolean xs_sidplay1_init(XSEngineState * myStatus)
+gboolean xs_sidplay1_init(XSEngineState * state)
 {
     gint tmpFreq;
-    xs_sidplay1_t *myEngine;
-    assert(myStatus);
+    xs_sidplay1_t *engine;
+    assert(state);
 
     /* Allocate internal structures */
-    myEngine = (xs_sidplay1_t *) g_malloc0(sizeof(xs_sidplay1_t));
-    if (!myEngine) return FALSE;
+    engine = (xs_sidplay1_t *) g_malloc0(sizeof(xs_sidplay1_t));
+    if (!engine) return FALSE;
 
     /* Initialize engine */
-    myEngine->currEng = new emuEngine();
-    if (!myEngine->currEng) {
+    engine->currEng = new emuEngine();
+    if (!engine->currEng) {
         xs_error("[SIDPlay1] Could not initialize emulation engine.\n");
-        g_free(myEngine);
+        g_free(engine);
         return FALSE;
     }
 
     /* Verify endianess */
-    if (!myEngine->currEng->verifyEndianess()) {
+    if (!engine->currEng->verifyEndianess()) {
         xs_error("[SIDPlay1] Endianess verification failed.\n");
-        delete myEngine->currEng;
-        g_free(myEngine);
+        delete engine->currEng;
+        g_free(engine);
         return FALSE;
     }
 
-    myStatus->internal = myEngine;
+    state->internal = engine;
 
     /* Get current configuration */
-    myEngine->currEng->getConfig(myEngine->currConfig);
+    engine->currEng->getConfig(engine->currConfig);
 
     /* Configure channel parameters */
-    switch (myStatus->audioChannels) {
+    switch (state->audioChannels) {
 
     case XS_CHN_AUTOPAN:
-        myEngine->currConfig.channels = SIDEMU_STEREO;
-        myEngine->currConfig.autoPanning = SIDEMU_CENTEREDAUTOPANNING;
-        myEngine->currConfig.volumeControl = SIDEMU_FULLPANNING;
+        engine->currConfig.channels = SIDEMU_STEREO;
+        engine->currConfig.autoPanning = SIDEMU_CENTEREDAUTOPANNING;
+        engine->currConfig.volumeControl = SIDEMU_FULLPANNING;
         break;
 
     case XS_CHN_STEREO:
-        myEngine->currConfig.channels = SIDEMU_STEREO;
-        myEngine->currConfig.autoPanning = SIDEMU_NONE;
-        myEngine->currConfig.volumeControl = SIDEMU_NONE;
+        engine->currConfig.channels = SIDEMU_STEREO;
+        engine->currConfig.autoPanning = SIDEMU_NONE;
+        engine->currConfig.volumeControl = SIDEMU_NONE;
         break;
 
     case XS_CHN_MONO:
     default:
-        myEngine->currConfig.channels = SIDEMU_MONO;
-        myEngine->currConfig.autoPanning = SIDEMU_NONE;
-        myEngine->currConfig.volumeControl = SIDEMU_NONE;
-        myStatus->audioChannels = XS_CHN_MONO;
+        engine->currConfig.channels = SIDEMU_MONO;
+        engine->currConfig.autoPanning = SIDEMU_NONE;
+        engine->currConfig.volumeControl = SIDEMU_NONE;
+        state->audioChannels = XS_CHN_MONO;
         break;
     }
 
@@ -139,62 +139,62 @@
     /* Memory mode settings */
     switch (xs_cfg.memoryMode) {
     case XS_MPU_TRANSPARENT_ROM:
-        myEngine->currConfig.memoryMode = MPU_TRANSPARENT_ROM;
+        engine->currConfig.memoryMode = MPU_TRANSPARENT_ROM;
         break;
 
     case XS_MPU_PLAYSID_ENVIRONMENT:
-        myEngine->currConfig.memoryMode = MPU_PLAYSID_ENVIRONMENT;
+        engine->currConfig.memoryMode = MPU_PLAYSID_ENVIRONMENT;
         break;
 
     case XS_MPU_BANK_SWITCHING:
     default:
-        myEngine->currConfig.memoryMode = MPU_BANK_SWITCHING;
+        engine->currConfig.memoryMode = MPU_BANK_SWITCHING;
         xs_cfg.memoryMode = XS_MPU_BANK_SWITCHING;
         break;
     }
 
 
     /* Audio parameters sanity checking and setup */
-    myEngine->currConfig.bitsPerSample = myStatus->audioBitsPerSample;
-    tmpFreq = myStatus->audioFrequency;
+    engine->currConfig.bitsPerSample = state->audioBitsPerSample;
+    tmpFreq = state->audioFrequency;
 
     if (tmpFreq > SIDPLAY1_MAX_FREQ)
         tmpFreq = SIDPLAY1_MAX_FREQ;
 
-    myEngine->currConfig.frequency = tmpFreq;
+    engine->currConfig.frequency = tmpFreq;
 
-    switch (myStatus->audioBitsPerSample) {
+    switch (state->audioBitsPerSample) {
     case XS_RES_8BIT:
-        switch (myStatus->audioFormat) {
+        switch (state->audioFormat) {
         case FMT_S8:
-            myStatus->audioFormat = FMT_S8;
-            myEngine->currConfig.sampleFormat = SIDEMU_SIGNED_PCM;
+            state->audioFormat = FMT_S8;
+            engine->currConfig.sampleFormat = SIDEMU_SIGNED_PCM;
             break;
 
         case FMT_U8:
         default:
-            myStatus->audioFormat = FMT_U8;
-            myEngine->currConfig.sampleFormat = SIDEMU_UNSIGNED_PCM;
+            state->audioFormat = FMT_U8;
+            engine->currConfig.sampleFormat = SIDEMU_UNSIGNED_PCM;
             break;
         }
         break;
 
     case XS_RES_16BIT:
     default:
-        switch (myStatus->audioFormat) {
+        switch (state->audioFormat) {
         case FMT_U16_NE:
         case FMT_U16_LE:
         case FMT_U16_BE:
-            myStatus->audioFormat = FMT_U16_NE;
-            myEngine->currConfig.sampleFormat = SIDEMU_UNSIGNED_PCM;
+            state->audioFormat = FMT_U16_NE;
+            engine->currConfig.sampleFormat = SIDEMU_UNSIGNED_PCM;
             break;
 
         case FMT_S16_NE:
         case FMT_S16_LE:
         case FMT_S16_BE:
         default:
-            myStatus->audioFormat = FMT_S16_NE;
-            myEngine->currConfig.sampleFormat = SIDEMU_SIGNED_PCM;
+            state->audioFormat = FMT_S16_NE;
+            engine->currConfig.sampleFormat = SIDEMU_SIGNED_PCM;
             break;
         }
         break;
@@ -203,37 +203,37 @@
     /* Clockspeed settings */
     switch (xs_cfg.clockSpeed) {
     case XS_CLOCK_NTSC:
-        myEngine->currConfig.clockSpeed = SIDTUNE_CLOCK_NTSC;
+        engine->currConfig.clockSpeed = SIDTUNE_CLOCK_NTSC;
         break;
 
     case XS_CLOCK_PAL:
     default:
-        myEngine->currConfig.clockSpeed = SIDTUNE_CLOCK_PAL;
+        engine->currConfig.clockSpeed = SIDTUNE_CLOCK_PAL;
         xs_cfg.clockSpeed = XS_CLOCK_PAL;
         break;
     }
 
-    myEngine->currConfig.forceSongSpeed = xs_cfg.forceSpeed;
+    engine->currConfig.forceSongSpeed = xs_cfg.forceSpeed;
     
     
     /* Configure rest of the emulation */
     /* if (xs_cfg.forceModel) */
-    myEngine->currConfig.mos8580 = xs_cfg.mos8580;
-    myEngine->currConfig.emulateFilter = xs_cfg.emulateFilters;
-    myEngine->currConfig.filterFs = xs_cfg.sid1Filter.fs;
-    myEngine->currConfig.filterFm = xs_cfg.sid1Filter.fm;
-    myEngine->currConfig.filterFt = xs_cfg.sid1Filter.ft;
+    engine->currConfig.mos8580 = xs_cfg.mos8580;
+    engine->currConfig.emulateFilter = xs_cfg.emulateFilters;
+    engine->currConfig.filterFs = xs_cfg.sid1Filter.fs;
+    engine->currConfig.filterFm = xs_cfg.sid1Filter.fm;
+    engine->currConfig.filterFt = xs_cfg.sid1Filter.ft;
 
 
     /* Now set the emulator configuration */
-    if (!myEngine->currEng->setConfig(myEngine->currConfig)) {
+    if (!engine->currEng->setConfig(engine->currConfig)) {
         xs_error("[SIDPlay1] Emulator engine configuration failed!\n");
         return FALSE;
     }
     
     /* Create sidtune object */
-    myEngine->currTune = new sidTune(0);
-    if (!myEngine->currTune) {
+    engine->currTune = new sidTune(0);
+    if (!engine->currTune) {
         xs_error("[SIDPlay1] Could not initialize SIDTune object.\n");
         return FALSE;
     }
@@ -244,68 +244,68 @@
 
 /* Close SIDPlay1 engine
  */
-void xs_sidplay1_close(XSEngineState * myStatus)
+void xs_sidplay1_close(XSEngineState * state)
 {
-    xs_sidplay1_t *myEngine;
-    assert(myStatus);
+    xs_sidplay1_t *engine;
+    assert(state);
 
-    myEngine = (xs_sidplay1_t *) myStatus->internal;
+    engine = (xs_sidplay1_t *) state->internal;
 
     /* Free internals */
-    if (myEngine->currEng) {
-        delete myEngine->currEng;
-        myEngine->currEng = NULL;
+    if (engine->currEng) {
+        delete engine->currEng;
+        engine->currEng = NULL;
     }
 
-    if (myEngine->currTune) {
-        delete myEngine->currTune;
-        myEngine->currTune = NULL;
+    if (engine->currTune) {
+        delete engine->currTune;
+        engine->currTune = NULL;
     }
 
-    xs_sidplay1_delete(myStatus);
+    xs_sidplay1_delete(state);
     
-    g_free(myEngine);
-    myStatus->internal = NULL;
+    g_free(engine);
+    state->internal = NULL;
 }
 
 
 /* Initialize current song and sub-tune
  */
-gboolean xs_sidplay1_initsong(XSEngineState * myStatus)
+gboolean xs_sidplay1_initsong(XSEngineState * state)
 {
-    xs_sidplay1_t *myEngine;
-    assert(myStatus);
+    xs_sidplay1_t *engine;
+    assert(state);
 
-    myEngine = (xs_sidplay1_t *) myStatus->internal;
-    if (!myEngine) return FALSE;
+    engine = (xs_sidplay1_t *) state->internal;
+    if (!engine) return FALSE;
 
-    if (!myEngine->currTune) {
+    if (!engine->currTune) {
         xs_error("[SIDPlay1] SID-tune struct pointer was NULL. This should not happen, report to XMMS-SID author.\n");
         return FALSE;
     }
 
-    if (!myEngine->currTune->getStatus()) {
+    if (!engine->currTune->getStatus()) {
         xs_error("[SIDPlay1] SID-tune status check failed. This should not happen, report to XMMS-SID author.\n");
         return FALSE;
     }
 
-    myStatus->isInitialized = TRUE;
+    state->isInitialized = TRUE;
 
-    return sidEmuInitializeSong(*myEngine->currEng, *myEngine->currTune, myStatus->currSong);
+    return sidEmuInitializeSong(*engine->currEng, *engine->currTune, state->currSong);
 }
 
 
 /* Emulate and render audio data to given buffer
  */
-guint xs_sidplay1_fillbuffer(XSEngineState * myStatus, gchar * audioBuffer, guint audioBufSize)
+guint xs_sidplay1_fillbuffer(XSEngineState * state, gchar * audioBuffer, guint audioBufSize)
 {
-    xs_sidplay1_t *myEngine;
-    assert(myStatus);
+    xs_sidplay1_t *engine;
+    assert(state);
 
-    myEngine = (xs_sidplay1_t *) myStatus->internal;
-    if (!myEngine) return 0;
+    engine = (xs_sidplay1_t *) state->internal;
+    if (!engine) return 0;
 
-    sidEmuFillBuffer(*myEngine->currEng, *myEngine->currTune, audioBuffer, audioBufSize);
+    sidEmuFillBuffer(*engine->currEng, *engine->currTune, audioBuffer, audioBufSize);
 
     return audioBufSize;
 }
@@ -313,22 +313,22 @@
 
 /* Load a given SID-tune file
  */
-gboolean xs_sidplay1_load(XSEngineState * myStatus, gchar * filename)
+gboolean xs_sidplay1_load(XSEngineState * state, gchar * filename)
 {
-    xs_sidplay1_t *myEngine;
-    assert(myStatus);
-    myStatus->isInitialized = FALSE;
+    xs_sidplay1_t *engine;
+    assert(state);
+    state->isInitialized = FALSE;
 
-    myEngine = (xs_sidplay1_t *) myStatus->internal;
-    if (!myEngine) return FALSE;
+    engine = (xs_sidplay1_t *) state->internal;
+    if (!engine) return FALSE;
 
     /* Try to get the tune */
     if (!filename) return FALSE;
     
-    if (xs_fload_buffer(filename, &(myEngine->buf), &(myEngine->bufSize)) != 0)
+    if (xs_fload_buffer(filename, &(engine->buf), &(engine->bufSize)) != 0)
         return FALSE;
     
-    if (!myEngine->currTune->load(myEngine->buf, myEngine->bufSize))
+    if (!engine->currTune->load(engine->buf, engine->bufSize))
         return FALSE;
 
     return TRUE;
@@ -337,17 +337,17 @@
 
 /* Delete INTERNAL information
  */
-void xs_sidplay1_delete(XSEngineState * myStatus)
+void xs_sidplay1_delete(XSEngineState * state)
 {
-    xs_sidplay1_t *myEngine;
-    assert(myStatus);
+    xs_sidplay1_t *engine;
+    assert(state);
 
-    myEngine = (xs_sidplay1_t *) myStatus->internal;
-    if (!myEngine) return;
+    engine = (xs_sidplay1_t *) state->internal;
+    if (!engine) return;
     
-    g_free(myEngine->buf);
-    myEngine->buf = NULL;
-    myEngine->bufSize = 0;
+    g_free(engine->buf);
+    engine->buf = NULL;
+    engine->bufSize = 0;
 }
 
 
--- a/src/xs_sidplay2.cc	Mon Nov 05 18:51:11 2012 +0200
+++ b/src/xs_sidplay2.cc	Mon Nov 05 18:52:10 2012 +0200
@@ -121,45 +121,45 @@
 
 /* Initialize SIDPlay2
  */
-gboolean xs_sidplay2_init(XSEngineState * myStatus)
+gboolean xs_sidplay2_init(XSEngineState * state)
 {
     gint i;
-    xs_sidplay2_t *myEngine;
+    xs_sidplay2_t *engine;
     sid_filter_t tmpFilter;
     xs_sid_filter_t *f;
-    assert(myStatus);
+    assert(state);
 
     /* Allocate internal structures */
-    myEngine = new xs_sidplay2_t();
-    myStatus->internal = myEngine;
-    if (!myEngine) return FALSE;
+    engine = new xs_sidplay2_t();
+    state->internal = engine;
+    if (!engine) return FALSE;
 
     /* Initialize the engine */
 #ifdef HAVE_SIDPLAY2_FP
-    myEngine->currEng = new sidplay2;
+    engine->currEng = new sidplay2;
 #endif
-    if (!myEngine->currEng) {
+    if (!engine->currEng) {
         xs_error("[SIDPlay2] Could not initialize emulation engine.\n");
         return FALSE;
     }
 
     /* Get current configuration */
-    myEngine->currConfig = myEngine->currEng->config();
+    engine->currConfig = engine->currEng->config();
 
     /* Configure channels and stuff */
-    switch (myStatus->audioChannels) {
+    switch (state->audioChannels) {
         case XS_CHN_AUTOPAN:
-            myEngine->currConfig.playback = sid2_stereo;
+            engine->currConfig.playback = sid2_stereo;
             break;
 
         case XS_CHN_STEREO:
-            myEngine->currConfig.playback = sid2_stereo;
+            engine->currConfig.playback = sid2_stereo;
             break;
 
         case XS_CHN_MONO:
         default:
-            myEngine->currConfig.playback = sid2_mono;
-            myStatus->audioChannels = XS_CHN_MONO;
+            engine->currConfig.playback = sid2_mono;
+            state->audioChannels = XS_CHN_MONO;
             break;
     }
 
@@ -167,20 +167,20 @@
     /* Memory mode settings */
     switch (xs_cfg.memoryMode) {
         case XS_MPU_BANK_SWITCHING:
-            myEngine->currConfig.environment = sid2_envBS;
+            engine->currConfig.environment = sid2_envBS;
             break;
 
         case XS_MPU_TRANSPARENT_ROM:
-            myEngine->currConfig.environment = sid2_envTP;
+            engine->currConfig.environment = sid2_envTP;
             break;
 
         case XS_MPU_PLAYSID_ENVIRONMENT:
-            myEngine->currConfig.environment = sid2_envPS;
+            engine->currConfig.environment = sid2_envPS;
             break;
 
         case XS_MPU_REAL:
         default:
-            myEngine->currConfig.environment = sid2_envR;
+            engine->currConfig.environment = sid2_envR;
             xs_cfg.memoryMode = XS_MPU_REAL;
             break;
     }
@@ -188,43 +188,43 @@
 
     /* Audio parameters sanity checking and setup */
 #ifndef HAVE_SIDPLAY2_FP
-    myEngine->currConfig.precision = myStatus->audioBitsPerSample;
+    engine->currConfig.precision = state->audioBitsPerSample;
 
 #else
-    myStatus->audioBitsPerSample = XS_RES_16BIT;
-    myEngine->currConfig.samplingMethod = SID2_RESAMPLE_INTERPOLATE;
+    state->audioBitsPerSample = XS_RES_16BIT;
+    engine->currConfig.samplingMethod = SID2_RESAMPLE_INTERPOLATE;
 #endif
 
-    myEngine->currConfig.frequency = myStatus->audioFrequency;
+    engine->currConfig.frequency = state->audioFrequency;
 
 
-    switch (myStatus->audioBitsPerSample) {
+    switch (state->audioBitsPerSample) {
     case XS_RES_8BIT:
-        myStatus->audioFormat = FMT_U8;
+        state->audioFormat = FMT_U8;
 #ifndef HAVE_SIDPLAY2_FP
-        myEngine->currConfig.sampleFormat = SID2_LITTLE_UNSIGNED;
+        engine->currConfig.sampleFormat = SID2_LITTLE_UNSIGNED;
 #endif
         break;
 
     case XS_RES_16BIT:
     default:
-            myStatus->audioFormat = FMT_S16_NE;
+            state->audioFormat = FMT_S16_NE;
 #ifndef HAVE_SIDPLAY2_FP
-        switch (myStatus->audioFormat) {
+        switch (state->audioFormat) {
         case FMT_U16_LE:
-            myEngine->currConfig.sampleFormat = SID2_LITTLE_UNSIGNED;
+            engine->currConfig.sampleFormat = SID2_LITTLE_UNSIGNED;
             break;
 
         case FMT_U16_BE:
-            myEngine->currConfig.sampleFormat = SID2_BIG_UNSIGNED;
+            engine->currConfig.sampleFormat = SID2_BIG_UNSIGNED;
             break;
 
         case FMT_U16_NE:
 #if G_BYTE_ORDER == G_BIG_ENDIAN
-            myEngine->currConfig.sampleFormat = SID2_BIG_UNSIGNED;
+            engine->currConfig.sampleFormat = SID2_BIG_UNSIGNED;
 #else
 #if G_BYTE_ORDER == G_LITTLE_ENDIAN
-            myEngine->currConfig.sampleFormat = SID2_LITTLE_UNSIGNED;
+            engine->currConfig.sampleFormat = SID2_LITTLE_UNSIGNED;
 #else
 #error Unsupported endianess!
 #endif
@@ -232,19 +232,19 @@
             break;
 
         case FMT_S16_LE:
-            myEngine->currConfig.sampleFormat = SID2_LITTLE_SIGNED;
+            engine->currConfig.sampleFormat = SID2_LITTLE_SIGNED;
             break;
 
         case FMT_S16_BE:
-            myEngine->currConfig.sampleFormat = SID2_BIG_SIGNED;
+            engine->currConfig.sampleFormat = SID2_BIG_SIGNED;
             break;
 
         default:
 #if G_BYTE_ORDER == G_BIG_ENDIAN
-            myEngine->currConfig.sampleFormat = SID2_BIG_SIGNED;
+            engine->currConfig.sampleFormat = SID2_BIG_SIGNED;
 #else
 #if G_BYTE_ORDER == G_LITTLE_ENDIAN
-            myEngine->currConfig.sampleFormat = SID2_LITTLE_SIGNED;
+            engine->currConfig.sampleFormat = SID2_LITTLE_SIGNED;
 #else
 #error Unsupported endianess!
 #endif
@@ -272,21 +272,21 @@
     }
 
     /* Initialize builder object */
-    XSDEBUG("init builder #%i, maxsids=%i\n", xs_cfg.sid2Builder, (myEngine->currEng->info()).maxsids);
+    XSDEBUG("init builder #%i, maxsids=%i\n", xs_cfg.sid2Builder, (engine->currEng->info()).maxsids);
 #ifdef HAVE_RESID_BUILDER
     if (xs_cfg.sid2Builder == XS_BLD_RESID) {
 #ifdef HAVE_SIDPLAY2_FP
         ReSIDBuilder *rs = new ReSIDBuilder("ReSID builder");
-        myEngine->currBuilder = (sidbuilder *) rs;
+        engine->currBuilder = (sidbuilder *) rs;
         if (rs) {
 #else
-        myEngine->currBuilder = ReSIDBuilderCreate("");
-        SidLazyIPtr<IReSIDBuilder> rs(myEngine->currBuilder);
+        engine->currBuilder = ReSIDBuilderCreate("");
+        SidLazyIPtr<IReSIDBuilder> rs(engine->currBuilder);
         if (rs) {
-            myEngine->currConfig.sidEmulation = rs->iaggregate();
+            engine->currConfig.sidEmulation = rs->iaggregate();
 #endif
             /* Builder object created, initialize it */
-            rs->create((myEngine->currEng->info()).maxsids);
+            rs->create((engine->currEng->info()).maxsids);
             if (!*rs) {
                 xs_error("reSID->create() failed.\n");
                 return FALSE;
@@ -324,16 +324,16 @@
     if (xs_cfg.sid2Builder == XS_BLD_HARDSID) {
 #ifdef HAVE_SIDPLAY2_FP
         HardSIDBuilder *hs = new HardSIDBuilder("HardSID builder");
-        myEngine->currBuilder = (sidbuilder *) hs;
+        engine->currBuilder = (sidbuilder *) hs;
         if (hs) {
 #else
-        myEngine->currBuilder = HardSIDBuilderCreate("");
-        SidLazyIPtr<IHardSIDBuilder> hs(myEngine->currBuilder);
+        engine->currBuilder = HardSIDBuilderCreate("");
+        SidLazyIPtr<IHardSIDBuilder> hs(engine->currBuilder);
         if (hs) {
-            myEngine->currConfig.sidEmulation = hs->iaggregate();
+            engine->currConfig.sidEmulation = hs->iaggregate();
 #endif
             /* Builder object created, initialize it */
-            hs->create((myEngine->currEng->info()).maxsids);
+            hs->create((engine->currEng->info()).maxsids);
             if (!*hs) {
                 xs_error("hardSID->create() failed.\n");
                 return FALSE;
@@ -348,20 +348,20 @@
     }
 #endif
 
-    if (!myEngine->currBuilder) {
+    if (!engine->currBuilder) {
         xs_error("[SIDPlay2] Could not initialize SIDBuilder object.\n");
         return FALSE;
     }
 
 #ifdef HAVE_SIDPLAY2_FP
-    myEngine->currConfig.sidEmulation = myEngine->currBuilder;
-    XSDEBUG("%s\n", myEngine->currBuilder->credits());
+    engine->currConfig.sidEmulation = engine->currBuilder;
+    XSDEBUG("%s\n", engine->currBuilder->credits());
 #endif
 
     /* Clockspeed settings */
     switch (xs_cfg.clockSpeed) {
     case XS_CLOCK_NTSC:
-        myEngine->currConfig.clockDefault = SID2_CLOCK_NTSC;
+        engine->currConfig.clockDefault = SID2_CLOCK_NTSC;
         break;
 
     default:
@@ -369,7 +369,7 @@
             xs_cfg.clockSpeed);
 
     case XS_CLOCK_PAL:
-        myEngine->currConfig.clockDefault = SID2_CLOCK_PAL;
+        engine->currConfig.clockDefault = SID2_CLOCK_PAL;
         xs_cfg.clockSpeed = XS_CLOCK_PAL;
         break;
     }
@@ -377,49 +377,49 @@
 
     /* Configure rest of the emulation */
     if (xs_cfg.forceSpeed) { 
-        myEngine->currConfig.clockForced = true;
-        myEngine->currConfig.clockSpeed = myEngine->currConfig.clockDefault;
+        engine->currConfig.clockForced = true;
+        engine->currConfig.clockSpeed = engine->currConfig.clockDefault;
     } else {
-        myEngine->currConfig.clockForced = false;
-        myEngine->currConfig.clockSpeed = SID2_CLOCK_CORRECT;
+        engine->currConfig.clockForced = false;
+        engine->currConfig.clockSpeed = SID2_CLOCK_CORRECT;
     }
     
 
 #if !defined(HAVE_SIDPLAY2_FP)
     if ((xs_cfg.sid2OptLevel >= 0) && (xs_cfg.sid2OptLevel <= SID2_MAX_OPTIMISATION))
-        myEngine->currConfig.optimisation = xs_cfg.sid2OptLevel;
+        engine->currConfig.optimisation = xs_cfg.sid2OptLevel;
     else {
         xs_error("Invalid sid2OptLevel=%d, falling back to %d.\n",
             xs_cfg.sid2OptLevel, SID2_DEFAULT_OPTIMISATION);
         
         xs_cfg.sid2OptLevel =
-        myEngine->currConfig.optimisation = SID2_DEFAULT_OPTIMISATION;
+        engine->currConfig.optimisation = SID2_DEFAULT_OPTIMISATION;
     }
 #endif
 
     if (xs_cfg.mos8580)
-        myEngine->currConfig.sidDefault = SID2_MOS8580;
+        engine->currConfig.sidDefault = SID2_MOS8580;
     else
-        myEngine->currConfig.sidDefault = SID2_MOS6581;
+        engine->currConfig.sidDefault = SID2_MOS6581;
 
     if (xs_cfg.forceModel)
-        myEngine->currConfig.sidModel = myEngine->currConfig.sidDefault;
+        engine->currConfig.sidModel = engine->currConfig.sidDefault;
     else
-        myEngine->currConfig.sidModel = SID2_MODEL_CORRECT;
+        engine->currConfig.sidModel = SID2_MODEL_CORRECT;
     
     /* XXX: Should this be configurable? libSIDPlay1 does not support it, though */
-    myEngine->currConfig.sidSamples = TRUE;
+    engine->currConfig.sidSamples = TRUE;
 
 
     /* Now set the emulator configuration */
-    if (myEngine->currEng->config(myEngine->currConfig) < 0) {
+    if (engine->currEng->config(engine->currConfig) < 0) {
         xs_error("[SIDPlay2] Emulator engine configuration failed!\n");
         return FALSE;
     }
 
     /* Create the sidtune */
-    myEngine->currTune = new SidTune(0);
-    if (!myEngine->currTune) {
+    engine->currTune = new SidTune(0);
+    if (!engine->currTune) {
         xs_error("[SIDPlay2] Could not initialize SIDTune object.\n");
         return FALSE;
     }
@@ -430,61 +430,61 @@
 
 /* Close SIDPlay2 engine
  */
-void xs_sidplay2_close(XSEngineState * myStatus)
+void xs_sidplay2_close(XSEngineState * state)
 {
-    xs_sidplay2_t *myEngine;
-    assert(myStatus);
+    xs_sidplay2_t *engine;
+    assert(state);
 
-    myEngine = (xs_sidplay2_t *) myStatus->internal;
+    engine = (xs_sidplay2_t *) state->internal;
 
     /* Free internals */
-    if (myEngine->currBuilder) {
+    if (engine->currBuilder) {
 #ifdef HAVE_SIDPLAY2_FP
-        delete myEngine->currBuilder;
+        delete engine->currBuilder;
 #endif
-        myEngine->currBuilder = NULL;
+        engine->currBuilder = NULL;
     }
 
 #ifdef HAVE_SIDPLAY2_FP
-    if (myEngine->currEng) {
-        delete myEngine->currEng;
-        myEngine->currEng = NULL;
+    if (engine->currEng) {
+        delete engine->currEng;
+        engine->currEng = NULL;
     }
 #endif
 
-    if (myEngine->currTune) {
-        delete myEngine->currTune;
-        myEngine->currTune = NULL;
+    if (engine->currTune) {
+        delete engine->currTune;
+        engine->currTune = NULL;
     }
 
-    xs_sidplay2_delete(myStatus);
+    xs_sidplay2_delete(state);
 
-    delete myEngine;
-    myStatus->internal = NULL;
+    delete engine;
+    state->internal = NULL;
 }
 
 
 /* Initialize current song and sub-tune
  */
-gboolean xs_sidplay2_initsong(XSEngineState * myStatus)
+gboolean xs_sidplay2_initsong(XSEngineState * state)
 {
-    xs_sidplay2_t *myEngine;
-    assert(myStatus);
+    xs_sidplay2_t *engine;
+    assert(state);
 
-    myEngine = (xs_sidplay2_t *) myStatus->internal;
-    if (!myEngine) return FALSE;
+    engine = (xs_sidplay2_t *) state->internal;
+    if (!engine) return FALSE;
 
-    if (!myEngine->currTune->selectSong(myStatus->currSong)) {
+    if (!engine->currTune->selectSong(state->currSong)) {
         xs_error("[SIDPlay2] currTune->selectSong() failed\n");
         return FALSE;
     }
 
-    if (myEngine->currEng->load(myEngine->currTune) < 0) {
+    if (engine->currEng->load(engine->currTune) < 0) {
         xs_error("[SIDPlay2] currEng->load() failed\n");
         return FALSE;
     }
     
-    myStatus->isInitialized = TRUE;
+    state->isInitialized = TRUE;
 
     return TRUE;
 }
@@ -492,36 +492,36 @@
 
 /* Emulate and render audio data to given buffer
  */
-guint xs_sidplay2_fillbuffer(XSEngineState * myStatus, gchar * audioBuffer, guint audioBufSize)
+guint xs_sidplay2_fillbuffer(XSEngineState * state, gchar * audioBuffer, guint audioBufSize)
 {
-    xs_sidplay2_t *myEngine;
-    assert(myStatus);
+    xs_sidplay2_t *engine;
+    assert(state);
 
-    myEngine = (xs_sidplay2_t *) myStatus->internal;
-    if (!myEngine) return 0;
+    engine = (xs_sidplay2_t *) state->internal;
+    if (!engine) return 0;
 
-    return myEngine->currEng->play((short *) audioBuffer, audioBufSize / sizeof(short));
+    return engine->currEng->play((short *) audioBuffer, audioBufSize / sizeof(short));
 }
 
 
 /* Load a given SID-tune file
  */
-gboolean xs_sidplay2_load(XSEngineState * myStatus, gchar * pcFilename)
+gboolean xs_sidplay2_load(XSEngineState * state, gchar * pcFilename)
 {
-    xs_sidplay2_t *myEngine;
-    assert(myStatus);
-    myStatus->isInitialized = FALSE;
+    xs_sidplay2_t *engine;
+    assert(state);
+    state->isInitialized = FALSE;
 
-    myEngine = (xs_sidplay2_t *) myStatus->internal;
-    if (!myEngine) return FALSE;
+    engine = (xs_sidplay2_t *) state->internal;
+    if (!engine) return FALSE;
 
     /* Try to get the tune */
     if (!pcFilename) return FALSE;
 
-    if (xs_fload_buffer(pcFilename, &(myEngine->buf), &(myEngine->bufSize)) != 0)
+    if (xs_fload_buffer(pcFilename, &(engine->buf), &(engine->bufSize)) != 0)
         return FALSE;
     
-    if (!myEngine->currTune->read(myEngine->buf, myEngine->bufSize))
+    if (!engine->currTune->read(engine->buf, engine->bufSize))
         return FALSE;
 
     return TRUE;
@@ -530,34 +530,34 @@
 
 /* Delete INTERNAL information
  */
-void xs_sidplay2_delete(XSEngineState * myStatus)
+void xs_sidplay2_delete(XSEngineState * state)
 {
-    xs_sidplay2_t *myEngine;
-    assert(myStatus);
+    xs_sidplay2_t *engine;
+    assert(state);
 
-    myEngine = (xs_sidplay2_t *) myStatus->internal;
-    if (!myEngine) return;
+    engine = (xs_sidplay2_t *) state->internal;
+    if (!engine) return;
     
-    g_free(myEngine->buf);
-    myEngine->buf = NULL;
-    myEngine->bufSize = 0;
+    g_free(engine->buf);
+    engine->buf = NULL;
+    engine->bufSize = 0;
 }
 
 
 /* Hardware backend flushing
  */
-void xs_sidplay2_flush(XSEngineState * myStatus)
+void xs_sidplay2_flush(XSEngineState * state)
 {
-    assert(myStatus);
+    assert(state);
 
 #ifdef HAVE_HARDSID_BUILDER
 #ifdef HSID_SID2_COM
-    IfPtr<HardSIDBuilder> hs(myStatus->currBuilder);
+    IfPtr<HardSIDBuilder> hs(state->currBuilder);
     if (hs)
         hs->flush();
 #else
     if (xs_cfg.sid2Builder == XS_BLD_HARDSID)
-        ((HardSIDBuilder *) myStatus->currBuilder)->flush();
+        ((HardSIDBuilder *) state->currBuilder)->flush();
 #endif
 #endif
 }