--- a/src/xs_sidplay2.cc	Mon Nov 05 22:40:01 2012 +0200
+++ b/src/xs_sidplay2.cc	Mon Nov 05 22:43:24 2012 +0200
@@ -50,14 +50,15 @@
 class XSSIDPlay2 {
 public:
 #ifdef HAVE_SIDPLAY2_FP
-    sidplay2 *currEng;
-    sidbuilder *currBuilder;
+    sidplay2 *emu;
+    sidbuilder *builder;
 #else
-    SidIPtr<ISidplay2> currEng;
-    SidLazyIPtr<ISidUnknown> currBuilder;
+    SidIPtr<ISidplay2> emu;
+    SidLazyIPtr<ISidUnknown> builder;
 #endif
-    sid2_config_t currConfig;
-    SidTune *currTune;
+    sid2_config_t config;
+    SidTune *tune;
+
     guint8 *buf;
     size_t bufSize;
     
@@ -85,15 +86,15 @@
 
 XSSIDPlay2::XSSIDPlay2(void)
 #ifdef HAVE_SIDPLAY2_FP
-:currEng(NULL)
+:emu(NULL)
 #else
-:currEng(sidplay2::create())
+:emu(sidplay2::create())
 #endif
 {
+    tune = NULL;
     buf = NULL;
     bufSize = 0;
-    currTune = NULL;
-    currBuilder = NULL;    
+    builder = NULL;    
 }
 
 
@@ -133,7 +134,6 @@
  */
 gboolean xs_sidplay2_init(XSEngineState * state)
 {
-    gint i;
     XSSIDPlay2 *engine;
     sid_filter_t tmpFilter;
     xs_sid_filter_t *f;
@@ -146,29 +146,30 @@
 
     /* Initialize the engine */
 #ifdef HAVE_SIDPLAY2_FP
-    engine->currEng = new sidplay2;
+    engine->emu = new sidplay2;
 #endif
-    if (!engine->currEng) {
+    if (!engine->emu)
+    {
         xs_error("[SIDPlay2] Could not initialize emulation engine.\n");
         return FALSE;
     }
 
     /* Get current configuration */
-    engine->currConfig = engine->currEng->config();
+    engine->config = engine->emu->config();
 
     /* Configure channels and stuff */
     switch (state->audioChannels) {
         case XS_CHN_AUTOPAN:
-            engine->currConfig.playback = sid2_stereo;
+            engine->config.playback = sid2_stereo;
             break;
 
         case XS_CHN_STEREO:
-            engine->currConfig.playback = sid2_stereo;
+            engine->config.playback = sid2_stereo;
             break;
 
         case XS_CHN_MONO:
         default:
-            engine->currConfig.playback = sid2_mono;
+            engine->config.playback = sid2_mono;
             state->audioChannels = XS_CHN_MONO;
             break;
     }
@@ -177,20 +178,20 @@
     /* Memory mode settings */
     switch (xs_cfg.memoryMode) {
         case XS_MPU_BANK_SWITCHING:
-            engine->currConfig.environment = sid2_envBS;
+            engine->config.environment = sid2_envBS;
             break;
 
         case XS_MPU_TRANSPARENT_ROM:
-            engine->currConfig.environment = sid2_envTP;
+            engine->config.environment = sid2_envTP;
             break;
 
         case XS_MPU_PLAYSID_ENVIRONMENT:
-            engine->currConfig.environment = sid2_envPS;
+            engine->config.environment = sid2_envPS;
             break;
 
         case XS_MPU_REAL:
         default:
-            engine->currConfig.environment = sid2_envR;
+            engine->config.environment = sid2_envR;
             xs_cfg.memoryMode = XS_MPU_REAL;
             break;
     }
@@ -199,19 +200,19 @@
     /* Audio parameters sanity checking and setup */
 #ifdef HAVE_SIDPLAY2_FP
     state->audioBitsPerSample = XS_RES_16BIT;
-    engine->currConfig.samplingMethod = SID2_RESAMPLE_INTERPOLATE;
+    engine->config.samplingMethod = SID2_RESAMPLE_INTERPOLATE;
 #else
-    engine->currConfig.precision = state->audioBitsPerSample;
+    engine->config.precision = state->audioBitsPerSample;
 #endif
 
-    engine->currConfig.frequency = state->audioFrequency;
+    engine->config.frequency = state->audioFrequency;
 
 
     switch (state->audioBitsPerSample) {
 #ifndef HAVE_SIDPLAY2_FP
         case XS_RES_8BIT:
             state->audioFormat = FMT_U8;
-            engine->currConfig.sampleFormat = SID2_LITTLE_UNSIGNED;
+            engine->config.sampleFormat = SID2_LITTLE_UNSIGNED;
             break;
 #endif
 
@@ -221,33 +222,34 @@
 #ifndef HAVE_SIDPLAY2_FP
             switch (state->audioFormat) {
                 case FMT_U16_LE:
-                    engine->currConfig.sampleFormat = SID2_LITTLE_UNSIGNED;
+                    engine->config.sampleFormat = SID2_LITTLE_UNSIGNED;
                     break;
 
                 case FMT_U16_BE:
-                    engine->currConfig.sampleFormat = SID2_BIG_UNSIGNED;
+                    engine->config.sampleFormat = SID2_BIG_UNSIGNED;
                     break;
 
                 case FMT_U16_NE:
-                    engine->currConfig.sampleFormat = SID2_NATIVE_UNSIGNED;
+                    engine->config.sampleFormat = SID2_NATIVE_UNSIGNED;
                     break;
 
                 case FMT_S16_LE:
-                    engine->currConfig.sampleFormat = SID2_LITTLE_SIGNED;
+                    engine->config.sampleFormat = SID2_LITTLE_SIGNED;
                     break;
 
                 case FMT_S16_BE:
-                    engine->currConfig.sampleFormat = SID2_BIG_SIGNED;
+                    engine->config.sampleFormat = SID2_BIG_SIGNED;
                     break;
 
                 default:
-                    engine->currConfig.sampleFormat = SID2_NATIVE_SIGNED;
+                    engine->config.sampleFormat = SID2_NATIVE_SIGNED;
                     break;
         }
 #endif
         break;
     }
     
+#if !defined(HAVE_SIDPLAY2_FP)
     /* Convert filter */
     f = &(xs_cfg.sid2Filter);
     XSDEBUG("using filter '%s', %d points\n", f->name, f->npoints);
@@ -262,126 +264,125 @@
         tmpFilter.cutoff[i][0] = f->points[i].x;
         tmpFilter.cutoff[i][1] = f->points[i].y;
     }
+#endif
 
     /* Initialize builder object */
-    XSDEBUG("init builder #%i, maxsids=%i\n", xs_cfg.sid2Builder, (engine->currEng->info()).maxsids);
+    XSDEBUG("init builder #%i, maxsids=%i\n", xs_cfg.sid2Builder, (engine->emu->info()).maxsids);
 
+    switch (xs_cfg.sid2Builder)
+    {
 #ifdef HAVE_RESID_BUILDER
-    if (xs_cfg.sid2Builder == XS_BLD_RESID) {
-
+        case XS_BLD_RESID:
 #ifdef HAVE_SIDPLAY2_FP
-        ReSIDBuilder *rs = new ReSIDBuilder("ReSID builder FP!");
-        engine->currBuilder = (sidbuilder *) rs;
-        if (rs) {
-            rs->create((engine->currEng->info()).maxsids);
-            if (!*rs) {
-                xs_error("reSID->create() failed.\n");
-                return FALSE;
-            }
-            rs->bias(0.0f);
-        }
-#else
-        engine->currBuilder = ReSIDBuilderCreate("ReSID builder");
-        SidLazyIPtr<IReSIDBuilder> rs(engine->currBuilder);
-        if (rs) {
-            engine->currConfig.sidEmulation = rs->iaggregate();
-            rs->create((engine->currEng->info()).maxsids);
-            if (!*rs) {
-                xs_error("reSID->create() failed.\n");
-                return FALSE;
-            }
+            {
+                ReSIDfpBuilder *rs = new ReSIDfpBuilder("ReSID builder FP!");
+                if (rs)
+                {
+                    engine->builder = rs;
+                    if (!*rs) return FALSE;
+                    rs->create((engine->emu->info()).maxsids);
+                    if (!*rs) return FALSE;
 
-            rs->filter(xs_cfg.emulateFilters);
-            if (!*rs) {
-                xs_error("reSID->filter(%d) failed.\n", xs_cfg.emulateFilters);
-                return FALSE;
-            }
-
-#if !defined(HAVE_SIDPLAY2_FP)
-            // FIXME FIX ME: support other configurable parameters ...
-            // ... WHEN/IF resid-builder+libsidplay2 gets fixed
-            rs->sampling(tmpFreq);
-            if (!*rs) {
-                xs_error("reSID->sampling(%d) failed.\n", tmpFreq);
-                return FALSE;
+/*
+                    if (m_filter.filterCurve6581)
+                        rs->filter6581Curve(m_filter.filterCurve6581);
+                    if (m_filter.filterCurve8580)
+                        rs->filter8580Curve((double)m_filter.filterCurve8580);
+*/
+                }
+#else
+                engine->builder = ReSIDBuilderCreate("ReSID builder");
+                SidLazyIPtr<IReSIDBuilder> rs(engine->builder);
+                if (rs)
+                {
+                    engine->config.sidEmulation = rs->iaggregate();
+                    rs->create((engine->emu->info()).maxsids);
+                    if (!*rs) return FALSE;
+                }
+#endif
             }
-            if (tmpFilter.points > 0)
-                rs->filter((sid_filter_t *) &tmpFilter);
-            else
-#endif
-                rs->filter((sid_filter_t *) NULL);
-            
-            if (!*rs) {
-                xs_error("reSID->filter(NULL) failed.\n");
-                return FALSE;
-            }
-        }
-#endif
-    }
+            break;
 #endif
 
 #ifdef HAVE_HARDSID_BUILDER
-    if (xs_cfg.sid2Builder == XS_BLD_HARDSID) {
+        case XS_BLD_HARDSID:
 #ifdef HAVE_SIDPLAY2_FP
-        HardSIDBuilder *hs = new HardSIDBuilder("HardSID builder");
-        engine->currBuilder = (sidbuilder *) hs;
-        if (hs) {
+            {
+                HardSIDBuilder *hs = new HardSIDBuilder("HardSID builder (FP)");
+                engine->builder = (sidbuilder *) hs;
+                if (hs)
+                {
 #else
-        engine->currBuilder = HardSIDBuilderCreate("");
-        SidLazyIPtr<IHardSIDBuilder> hs(engine->currBuilder);
-        if (hs) {
-            engine->currConfig.sidEmulation = hs->iaggregate();
+                engine->builder = HardSIDBuilderCreate("HardSID builder");
+                SidLazyIPtr<IHardSIDBuilder> hs(engine->builder);
+                if (hs)
+                {
+                    engine->config.sidEmulation = hs->iaggregate();
 #endif
-            /* Builder object created, initialize it */
-            hs->create((engine->currEng->info()).maxsids);
-            if (!*hs) {
-                xs_error("hardSID->create() failed.\n");
-                return FALSE;
+                    /* Builder object created, initialize it */
+                    hs->create((engine->emu->info()).maxsids);
+                    if (!*hs)
+                    {
+                        xs_error("hardSID->create() failed.\n");
+                        return FALSE;
+                    }
+                }
             }
+            break;
+#endif
+        
+        default:
+            xs_error("[SIDPlay2] Invalid or unsupported builder selected.\n");
+            break;
+    }
 
-            hs->filter(xs_cfg.emulateFilters);
-            if (!*hs) {
-                xs_error("hardSID->filter(%d) failed.\n", xs_cfg.emulateFilters);
-                return FALSE;
-            }
-        }
-    }
-#endif
-
-    if (!engine->currBuilder) {
+    if (!engine->builder)
+    {
         xs_error("[SIDPlay2] Could not initialize SIDBuilder object.\n");
         return FALSE;
     }
 
+    // Setup filter
+    engine->builder->filter(xs_cfg.emulateFilters);
+    if (!*(engine->builder))
+    {
+        xs_error("builder->filter(%d) failed.\n", xs_cfg.emulateFilters);
+        return FALSE;
+    }
+
 #ifdef HAVE_SIDPLAY2_FP
-    engine->currConfig.sidEmulation = engine->currBuilder;
-    XSDEBUG("%s\n", engine->currBuilder->credits());
+    engine->config.sidEmulation = engine->builder;
+    XSDEBUG("%s\n", engine->builder->credits());
 #endif
 
     /* Clockspeed settings */
-    switch (xs_cfg.clockSpeed) {
-    case XS_CLOCK_NTSC:
-        engine->currConfig.clockDefault = SID2_CLOCK_NTSC;
-        break;
+    switch (xs_cfg.clockSpeed)
+    {
+        case XS_CLOCK_NTSC:
+            engine->config.clockDefault = SID2_CLOCK_NTSC;
+            break;
 
-    default:
-        xs_error("[SIDPlay2] Invalid clockSpeed=%d, falling back to PAL.\n",
-            xs_cfg.clockSpeed);
+        default:
+            xs_error("[SIDPlay2] Invalid clockSpeed=%d, falling back to PAL.\n",
+                xs_cfg.clockSpeed);
 
-    case XS_CLOCK_PAL:
-        engine->currConfig.clockDefault = SID2_CLOCK_PAL;
-        xs_cfg.clockSpeed = XS_CLOCK_PAL;
-        break;
+        case XS_CLOCK_PAL:
+            engine->config.clockDefault = SID2_CLOCK_PAL;
+            xs_cfg.clockSpeed = XS_CLOCK_PAL;
+            break;
     }
 
 
     /* Configure rest of the emulation */
-    if (xs_cfg.forceSpeed) { 
-        engine->currConfig.clockForced = true;
-        engine->currConfig.clockSpeed = engine->currConfig.clockDefault;
-    } else {
-        engine->currConfig.clockForced = false;
-        engine->currConfig.clockSpeed = SID2_CLOCK_CORRECT;
+    if (xs_cfg.forceSpeed)
+    { 
+        engine->config.clockForced = true;
+        engine->config.clockSpeed = engine->config.clockDefault;
+    }
+    else
+    {
+        engine->config.clockForced = false;
+        engine->config.clockSpeed = SID2_CLOCK_CORRECT;
     }
     
 
@@ -396,33 +397,17 @@
     engine->currConfig.optimisation = xs_cfg.sid2OptLevel;
 #endif
 
-    if (xs_cfg.mos8580)
-        engine->currConfig.sidDefault = SID2_MOS8580;
-    else
-        engine->currConfig.sidDefault = SID2_MOS6581;
-
-    if (xs_cfg.forceModel)
-        engine->currConfig.sidModel = engine->currConfig.sidDefault;
-    else
-        engine->currConfig.sidModel = SID2_MODEL_CORRECT;
-    
-    /* XXX: Should this be configurable? libSIDPlay1 does not support it, though */
-    engine->currConfig.sidSamples = TRUE;
-
+    engine->config.sidDefault = xs_cfg.mos8580 ? SID2_MOS8580 : SID2_MOS6581;
+    engine->config.sidModel   = xs_cfg.forceModel ? engine->config.sidDefault : SID2_MODEL_CORRECT;
+    engine->config.sidSamples = TRUE;
 
     /* Now set the emulator configuration */
-    if (engine->currEng->config(engine->currConfig) < 0) {
+    if (engine->emu->config(engine->config) < 0)
+    {
         xs_error("[SIDPlay2] Emulator engine configuration failed!\n");
         return FALSE;
     }
 
-    /* Create the sidtune */
-    engine->currTune = new SidTune(0);
-    if (!engine->currTune) {
-        xs_error("[SIDPlay2] Could not initialize SIDTune object.\n");
-        return FALSE;
-    }
-
     return TRUE;
 }
 
@@ -437,25 +422,21 @@
     engine = (XSSIDPlay2 *) state->internal;
 
     /* Free internals */
-    if (engine->currBuilder) {
+    if (engine->builder) {
 #ifdef HAVE_SIDPLAY2_FP
-        delete engine->currBuilder;
+        delete engine->builder;
 #endif
-        engine->currBuilder = NULL;
+        engine->builder = NULL;
     }
 
 #ifdef HAVE_SIDPLAY2_FP
-    if (engine->currEng) {
-        delete engine->currEng;
-        engine->currEng = NULL;
+    if (engine->emu)
+    {
+        delete engine->emu;
+        engine->emu = NULL;
     }
 #endif
 
-    if (engine->currTune) {
-        delete engine->currTune;
-        engine->currTune = NULL;
-    }
-
     xs_sidplay2_delete(state);
 
     delete engine;
@@ -473,13 +454,13 @@
     engine = (XSSIDPlay2 *) state->internal;
     if (!engine) return FALSE;
 
-    if (!engine->currTune->selectSong(state->currSong)) {
-        xs_error("[SIDPlay2] currTune->selectSong() failed\n");
+    if (!engine->tune->selectSong(state->currSong)) {
+        xs_error("[SIDPlay2] tune->selectSong() failed\n");
         return FALSE;
     }
 
-    if (engine->currEng->load(engine->currTune) < 0) {
-        xs_error("[SIDPlay2] currEng->load() failed\n");
+    if (engine->emu->load(engine->tune) < 0) {
+        xs_error("[SIDPlay2] emu->load() failed\n");
         return FALSE;
     }
     
@@ -499,13 +480,13 @@
     engine = (XSSIDPlay2 *) state->internal;
     if (!engine) return 0;
 
-    return engine->currEng->play((short *) audioBuffer, audioBufSize / sizeof(short));
+    return engine->emu->play((short *) audioBuffer, audioBufSize / sizeof(short));
 }
 
 
 /* Load a given SID-tune file
  */
-gboolean xs_sidplay2_load(XSEngineState * state, gchar * pcFilename)
+gboolean xs_sidplay2_load(XSEngineState * state, gchar * filename)
 {
     XSSIDPlay2 *engine;
     assert(state);
@@ -514,13 +495,10 @@
     engine = (XSSIDPlay2 *) state->internal;
     if (!engine) return FALSE;
 
-    /* Try to get the tune */
-    if (!pcFilename) return FALSE;
-
-    if (xs_fload_buffer(pcFilename, &(engine->buf), &(engine->bufSize)) != 0)
+    if (xs_fload_buffer(filename, &(engine->buf), &(engine->bufSize)) != 0)
         return FALSE;
     
-    if (!engine->currTune->read(engine->buf, engine->bufSize))
+    if (!(engine->tune = new SidTune(filename)))
         return FALSE;
 
     return TRUE;
@@ -535,7 +513,14 @@
     assert(state);
 
     engine = (XSSIDPlay2 *) state->internal;
-    if (!engine) return;
+    if (!engine)
+        return;
+    
+    if (engine->tune)
+    {
+        delete engine->tune;
+        engine->tune = NULL;
+    }
     
     g_free(engine->buf);
     engine->buf = NULL;
@@ -551,12 +536,12 @@
 
 #ifdef HAVE_HARDSID_BUILDER
 #ifdef HSID_SID2_COM
-    IfPtr<HardSIDBuilder> hs(state->currBuilder);
+    IfPtr<HardSIDBuilder> hs(state->builder);
     if (hs)
         hs->flush();
 #else
     if (xs_cfg.sid2Builder == XS_BLD_HARDSID)
-        ((HardSIDBuilder *) state->currBuilder)->flush();
+        ((HardSIDBuilder *) state->builder)->flush();
 #endif
 #endif
 }