Replace pointers by shared_ptr in all flowgraph

11 files changed, 176 insertions, 165 deletions

diff --git a/src/Buffer.cpp b/src/Buffer.cpp
index aa0ef4c..fa7f52f 100644
--- a/src/Buffer.cpp
+++ b/src/Buffer.cpp
@@ -47,6 +47,7 @@ Buffer::Buffer(size_t len, const void *data)
 
 Buffer::~Buffer()
 {
+    PDEBUG("Buffer::~Buffer() len=%zu, data=%p\n", len, data);
     free(data);
 }
 
diff --git a/src/DabMod.cpp b/src/DabMod.cpp
index f546e45..1f6eedf 100644
--- a/src/DabMod.cpp
+++ b/src/DabMod.cpp
@@ -46,6 +46,7 @@
 #include "FIRFilter.h"
 #include "RemoteControl.h"
 
+#include <boost/shared_ptr.hpp>
 #include <boost/property_tree/ptree.hpp>
 #include <boost/property_tree/ini_parser.hpp>
 #include <complex>
@@ -73,6 +74,7 @@
 
 typedef std::complex<float> complexf;
 
+using namespace boost;
 
 volatile sig_atomic_t running = 1;
 
@@ -134,11 +136,9 @@ int main(int argc, char* argv[])
     modconf.use_offset_fixed = false;
     modconf.delay_calculation_pipeline_stages = 0;
 
-    Flowgraph* flowgraph = NULL;
-    DabModulator* modulator = NULL;
-    InputMemory* input = NULL;
-    FormatConverter* format_converter = NULL;
-    ModOutput* output = NULL;
+    shared_ptr<Flowgraph> flowgraph(new Flowgraph());
+    shared_ptr<FormatConverter> format_converter;
+    shared_ptr<ModOutput> output;
 
     RemoteControllers rcs;
 
@@ -188,7 +188,7 @@ int main(int argc, char* argv[])
 #if defined(HAVE_OUTPUT_UHD)
             if (useUHDOutput) {
                 fprintf(stderr, "Options -u and -f are mutually exclusive\n");
-                goto END_MAIN;
+                throw std::invalid_argument("Invalid command line options");
             }
 #endif
             outputName = optarg;
@@ -214,7 +214,7 @@ int main(int argc, char* argv[])
             if (modconf.use_offset_file)
             {
                 fprintf(stderr, "Options -o and -O are mutually exclusive\n");
-                goto END_MAIN;
+                throw std::invalid_argument("Invalid command line options");
             }
             modconf.use_offset_fixed = true;
             modconf.offset_fixed = strtod(optarg, NULL);
@@ -226,7 +226,7 @@ int main(int argc, char* argv[])
             if (modconf.use_offset_fixed)
             {
                 fprintf(stderr, "Options -o and -O are mutually exclusive\n");
-                goto END_MAIN;
+                throw std::invalid_argument("Invalid command line options");
             }
             modconf.use_offset_file = true;
             modconf.offset_filename = std::string(optarg);
@@ -247,7 +247,7 @@ int main(int argc, char* argv[])
 #if defined(HAVE_OUTPUT_UHD)
             if (useFileOutput) {
                 fprintf(stderr, "Options -u and -f are mutually exclusive\n");
-                goto END_MAIN;
+                throw std::invalid_argument("Invalid command line options");
             }
             outputuhd_conf.device = optarg;
             useUHDOutput = 1;
@@ -255,17 +255,17 @@ int main(int argc, char* argv[])
             break;
         case 'V':
             printVersion();
-            goto END_MAIN;
+            throw std::invalid_argument("");
             break;
         case '?':
         case 'h':
             printUsage(argv[0]);
-            goto END_MAIN;
+            throw std::invalid_argument("");
             break;
         default:
             fprintf(stderr, "Option '%c' not coded yet!\n", c);
             ret = -1;
-            goto END_MAIN;
+            throw std::invalid_argument("Invalid command line options");
         }
     }
 
@@ -306,7 +306,7 @@ int main(int argc, char* argv[])
     // No argument given ? You can't be serious ! Show usage.
     if (argc == 1) {
         printUsage(argv[0]);
-        goto END_MAIN;
+        throw std::invalid_argument("Invalid command line options");
     }
 
     // If only one argument is given, interpret as configuration file name
@@ -326,7 +326,7 @@ int main(int argc, char* argv[])
         catch (boost::property_tree::ini_parser::ini_parser_error &e)
         {
             fprintf(stderr, "Error, cannot read configuration file '%s'\n", configuration_file.c_str());
-            goto END_MAIN;
+            throw std::runtime_error("Cannot read configuration file");
         }
 
         // remote controller:
@@ -339,7 +339,7 @@ int main(int argc, char* argv[])
             catch (std::exception &e) {
                 std::cerr << "Error: " << e.what() << "\n";
                 std::cerr << "       telnet remote control enabled, but no telnetport defined.\n";
-                goto END_MAIN;
+                throw std::runtime_error("Configuration error");
             }
         }
 
@@ -354,7 +354,7 @@ int main(int argc, char* argv[])
             catch (std::exception &e) {
                 std::cerr << "Error: " << e.what() << "\n";
                 std::cerr << "       zmq remote control enabled, but no endpoint defined.\n";
-                goto END_MAIN;
+                throw std::runtime_error("Configuration error");
             }
         }
 #endif
@@ -384,7 +384,7 @@ int main(int argc, char* argv[])
             catch (std::exception &e) {
                 std::cerr << "Error: " << e.what() << "\n";
                 std::cerr << "       Configuration enables file log, but does not specify log filename\n";
-                goto END_MAIN;
+                throw std::runtime_error("Configuration error");
             }
 
             LogToFile* log_file = new LogToFile(logfilename);
@@ -407,7 +407,7 @@ int main(int argc, char* argv[])
             catch (std::exception &e) {
                 std::cerr << "Error: " << e.what() << "\n";
                 std::cerr << "       Configuration enables firfilter, but does not specify filter taps file\n";
-                goto END_MAIN;
+                throw std::runtime_error("Configuration error");
             }
         }
 
@@ -419,7 +419,7 @@ int main(int argc, char* argv[])
         catch (std::exception &e) {
             std::cerr << "Error: " << e.what() << "\n";
             std::cerr << "       Configuration does not specify output\n";
-            goto END_MAIN;
+            throw std::runtime_error("Configuration error");
         }
 
         if (output_selected == "file") {
@@ -429,7 +429,7 @@ int main(int argc, char* argv[])
             catch (std::exception &e) {
                 std::cerr << "Error: " << e.what() << "\n";
                 std::cerr << "       Configuration does not specify file name for file output\n";
-                goto END_MAIN;
+                throw std::runtime_error("Configuration error");
             }
             useFileOutput = 1;
 
@@ -459,7 +459,7 @@ int main(int argc, char* argv[])
 
             if (outputuhd_conf.frequency == 0 && chan == "") {
                 std::cerr << "       UHD output enabled, but neither frequency nor channel defined.\n";
-                goto END_MAIN;
+                throw std::runtime_error("Configuration error");
             }
             else if (outputuhd_conf.frequency == 0) {
                 double freq;
@@ -503,13 +503,13 @@ int main(int argc, char* argv[])
                 else if (chan == "13F") freq = 239200000;
                 else {
                     std::cerr << "       UHD output: channel " << chan << " does not exist in table\n";
-                    goto END_MAIN;
+                    throw std::out_of_range("UHD channel selection error");
                 }
                 outputuhd_conf.frequency = freq;
             }
             else if (outputuhd_conf.frequency != 0 && chan != "") {
                 std::cerr << "       UHD output: cannot define both frequency and channel.\n";
-                goto END_MAIN;
+                throw std::runtime_error("Configuration error");
             }
 
 
@@ -527,7 +527,7 @@ int main(int argc, char* argv[])
             }
             else {
                 std::cerr << "Error: UHD output: behaviour_refclk_lock_lost invalid." << std::endl;
-                goto END_MAIN;
+                throw std::runtime_error("Configuration error");
             }
 
             useUHDOutput = 1;
@@ -541,7 +541,7 @@ int main(int argc, char* argv[])
 #endif
         else {
             std::cerr << "Error: Invalid output defined.\n";
-            goto END_MAIN;
+            throw std::runtime_error("Configuration error");
         }
 
 #if defined(HAVE_OUTPUT_UHD)
@@ -564,7 +564,7 @@ int main(int argc, char* argv[])
             catch (std::exception &e) {
                 std::cerr << "Error: " << e.what() << "\n";
                 std::cerr << "       Synchronised transmission enabled, but delay management specification is incomplete.\n";
-                goto END_MAIN;
+                throw std::runtime_error("Configuration error");
             }
         }
 
@@ -618,13 +618,13 @@ int main(int argc, char* argv[])
         printUsage(argv[0]);
         ret = -1;
         logger.level(error) << "Received invalid command line arguments";
-        goto END_MAIN;
+        throw std::invalid_argument("Invalid command line options");
     }
 
     if (!useFileOutput && !useUHDOutput && !useZeroMQOutput) {
         logger.level(error) << "Output not specified";
         fprintf(stderr, "Must specify output !");
-        goto END_MAIN;
+        throw std::runtime_error("Configuration error");
     }
 
     // Print settings
@@ -670,7 +670,7 @@ int main(int argc, char* argv[])
             fprintf(stderr, "Unable to open input file!\n");
             logger.level(error) << "Unable to open input file!";
             ret = -1;
-            goto END_MAIN;
+            throw std::runtime_error("Unable to open input");
         }
 
         inputReader = &inputFileReader;
@@ -679,7 +679,7 @@ int main(int argc, char* argv[])
 #if !defined(HAVE_ZEROMQ)
         fprintf(stderr, "Error, ZeroMQ input transport selected, but not compiled in!\n");
         ret = -1;
-        goto END_MAIN;
+        throw std::runtime_error("Unable to open input");
 #else
         // The URL might start with zmq+tcp://
         if (inputName.substr(0, 4) == "zmq+") {
@@ -695,20 +695,20 @@ int main(int argc, char* argv[])
     {
         fprintf(stderr, "Error, invalid input transport %s selected!\n", inputTransport.c_str());
         ret = -1;
-        goto END_MAIN;
+        throw std::runtime_error("Unable to open input");
     }
 
     if (useFileOutput) {
         if (fileOutputFormat == "complexf") {
-            output = new OutputFile(outputName);
+            output = shared_ptr<OutputFile>(new OutputFile(outputName));
         }
         else if (fileOutputFormat == "s8") {
             // We must normalise the samples to the interval [-127.0; 127.0]
             normalise = 127.0f / normalise_factor;
 
-            format_converter = new FormatConverter();
+            format_converter = shared_ptr<FormatConverter>(new FormatConverter());
 
-            output = new OutputFile(outputName);
+            output = shared_ptr<OutputFile>(new OutputFile(outputName));
         }
     }
 #if defined(HAVE_OUTPUT_UHD)
@@ -717,14 +717,8 @@ int main(int argc, char* argv[])
         normalise = 1.0f / normalise_factor;
 
         outputuhd_conf.sampleRate = outputRate;
-        try {
-            output = new OutputUHD(outputuhd_conf, logger);
-            ((OutputUHD*)output)->enrol_at(rcs);
-        }
-        catch (std::exception& e) {
-            logger.level(error) << "UHD initialisation failed:" << e.what();
-            goto END_MAIN;
-        }
+        output = shared_ptr<OutputUHD>(new OutputUHD(outputuhd_conf, logger));
+        ((OutputUHD*)output.get())->enrol_at(rcs);
     }
 #endif
 #if defined(HAVE_ZEROMQ)
@@ -732,15 +726,14 @@ int main(int argc, char* argv[])
         /* We normalise the same way as for the UHD output */
         normalise = 1.0f / normalise_factor;
 
-        output = new OutputZeroMQ(outputName);
+        output = shared_ptr<OutputZeroMQ>(new OutputZeroMQ(outputName));
     }
 #endif
 
-    flowgraph = new Flowgraph();
     data.setLength(6144);
-    input = new InputMemory(&data);
-    modulator = new DabModulator(modconf, &rcs, logger, outputRate, clockRate,
-            dabMode, gainMode, digitalgain, normalise, filterTapsFilename);
+    shared_ptr<InputMemory> input(new InputMemory(&data));
+    shared_ptr<DabModulator> modulator(new DabModulator(modconf, &rcs, logger, outputRate, clockRate,
+            dabMode, gainMode, digitalgain, normalise, filterTapsFilename));
     flowgraph->connect(input, modulator);
     if (format_converter) {
         flowgraph->connect(modulator, format_converter);
@@ -752,7 +745,7 @@ int main(int argc, char* argv[])
 
 #if defined(HAVE_OUTPUT_UHD)
     if (useUHDOutput) {
-        ((OutputUHD*)output)->setETIReader(modulator->getEtiReader());
+        ((OutputUHD*)output.get())->setETIReader(modulator->getEtiReader());
     }
 #endif
 
@@ -801,7 +794,6 @@ int main(int argc, char* argv[])
         ret = -1;
     }
 
-END_MAIN:
     ////////////////////////////////////////////////////////////////////////
     // Cleaning things
     ////////////////////////////////////////////////////////////////////////
@@ -809,9 +801,6 @@ END_MAIN:
     fprintf(stderr, "%lu DAB frames encoded\n", frame);
     fprintf(stderr, "%f seconds encoded\n", (float)frame * 0.024f);
 
-    fprintf(stderr, "\nCleaning flowgraph...\n");
-    delete flowgraph;
-
     // Cif
     fprintf(stderr, "\nCleaning buffers...\n");
 
diff --git a/src/DabModulator.cpp b/src/DabModulator.cpp
index 2664a08..287280c 100644
--- a/src/DabModulator.cpp
+++ b/src/DabModulator.cpp
@@ -3,8 +3,10 @@
    Her Majesty the Queen in Right of Canada (Communications Research
    Center Canada)
 
-   Includes modifications for which no copyright is claimed
-   2012, Matthias P. Braendli, matthias.braendli@mpb.li
+   Copyright (C) 2015
+   Matthias P. Braendli, matthias.braendli@mpb.li
+
+    http://opendigitalradio.org
  */
 /*
    This file is part of ODR-DabMod.
@@ -50,6 +52,7 @@
 #include "RemoteControl.h"
 #include "Log.h"
 
+using namespace boost;
 
 DabModulator::DabModulator(
         struct modulator_offset_config& modconf,
@@ -155,62 +158,65 @@ int DabModulator::process(Buffer* const dataIn, Buffer* dataOut)
         ////////////////////////////////////////////////////////////////
         // CIF data initialisation
         ////////////////////////////////////////////////////////////////
-        FrameMultiplexer* cifMux = NULL;
-        PrbsGenerator* cifPrbs = NULL;
-        BlockPartitioner* cifPart = NULL;
-        QpskSymbolMapper* cifMap = NULL;
-        FrequencyInterleaver* cifFreq = NULL;
-        PhaseReference* cifRef = NULL;
-        DifferentialModulator* cifDiff = NULL;
-        NullSymbol* cifNull = NULL;
-        SignalMultiplexer* cifSig = NULL;
-        CicEqualizer* cifCicEq = NULL;
-        OfdmGenerator* cifOfdm = NULL;
-        GainControl* cifGain = NULL;
-        GuardIntervalInserter* cifGuard = NULL;
-        FIRFilter* cifFilter = NULL;
-        Resampler* cifRes = NULL;
-
-        cifPrbs = new PrbsGenerator(864 * 8, 0x110);
-        cifMux = new FrameMultiplexer(myFicSizeOut + 864 * 8,
-                &myEtiReader.getSubchannels());
-        cifPart = new BlockPartitioner(mode, myEtiReader.getFp());
-        cifMap = new QpskSymbolMapper(myNbCarriers);
-        cifRef = new PhaseReference(mode);
-        cifFreq = new FrequencyInterleaver(mode);
-        cifDiff = new DifferentialModulator(myNbCarriers);
-        cifNull = new NullSymbol(myNbCarriers);
-        cifSig = new SignalMultiplexer(
-                (1 + myNbSymbols) * myNbCarriers * sizeof(complexf));
-
+        shared_ptr<PrbsGenerator> cifPrbs(new PrbsGenerator(864 * 8, 0x110));
+        shared_ptr<FrameMultiplexer> cifMux(
+                new FrameMultiplexer(myFicSizeOut + 864 * 8,
+                &myEtiReader.getSubchannels()));
+
+        shared_ptr<BlockPartitioner> cifPart(
+                new BlockPartitioner(mode, myEtiReader.getFp()));
+
+        shared_ptr<QpskSymbolMapper> cifMap(new QpskSymbolMapper(myNbCarriers));
+        shared_ptr<PhaseReference> cifRef(new PhaseReference(mode));
+        shared_ptr<FrequencyInterleaver> cifFreq(new FrequencyInterleaver(mode));
+        shared_ptr<DifferentialModulator> cifDiff(
+                new DifferentialModulator(myNbCarriers));
+
+        shared_ptr<NullSymbol> cifNull(new NullSymbol(myNbCarriers));
+        shared_ptr<SignalMultiplexer> cifSig(new SignalMultiplexer(
+                (1 + myNbSymbols) * myNbCarriers * sizeof(complexf)));
+
+        // TODO this needs a review
+        bool useCicEq = false;
+        unsigned cic_ratio = 1;
         if (myClockRate) {
-            unsigned ratio = myClockRate / myOutputRate;
-            ratio /= 4; // FPGA DUC
+            cic_ratio = myClockRate / myOutputRate;
+            cic_ratio /= 4; // FPGA DUC
             if (myClockRate == 400000000) { // USRP2
-                if (ratio & 1) { // odd
-                    cifCicEq = new CicEqualizer(myNbCarriers,
-                            (float)mySpacing * (float)myOutputRate / 2048000.0f,
-                            ratio);
+                if (cic_ratio & 1) { // odd
+                    useCicEq = true;
                 } // even, no filter
-            } else {
-                cifCicEq = new CicEqualizer(myNbCarriers,
-                        (float)mySpacing * (float)myOutputRate / 2048000.0f,
-                        ratio);
+            }
+            else {
+                useCicEq = true;
             }
         }
 
-        cifOfdm = new OfdmGenerator((1 + myNbSymbols), myNbCarriers, mySpacing);
-        cifGain = new GainControl(mySpacing, myGainMode, myDigGain, myNormalise);
+        shared_ptr<CicEqualizer> cifCicEq(new CicEqualizer(myNbCarriers,
+                (float)mySpacing * (float)myOutputRate / 2048000.0f,
+                cic_ratio));
+
+
+        shared_ptr<OfdmGenerator> cifOfdm(
+                new OfdmGenerator((1 + myNbSymbols), myNbCarriers, mySpacing));
+
+        shared_ptr<GainControl> cifGain(
+                new GainControl(mySpacing, myGainMode, myDigGain, myNormalise));
+
         cifGain->enrol_at(*myRCs);
 
-        cifGuard = new GuardIntervalInserter(myNbSymbols, mySpacing,
-                myNullSize, mySymSize);
+        shared_ptr<GuardIntervalInserter> cifGuard(
+                new GuardIntervalInserter(myNbSymbols, mySpacing,
+                myNullSize, mySymSize));
+
+        FIRFilter* cifFilter = NULL;
         if (myFilterTapsFilename != "") {
             cifFilter = new FIRFilter(myFilterTapsFilename);
             cifFilter->enrol_at(*myRCs);
         }
-        myOutput = new OutputMemory();
+        shared_ptr<OutputMemory> myOutput(new OutputMemory(dataOut));
 
+        Resampler* cifRes = NULL;
         if (myOutputRate != 2048000) {
             cifRes = new Resampler(2048000, myOutputRate, mySpacing);
         } else {
@@ -222,10 +228,7 @@ int DabModulator::process(Buffer* const dataIn, Buffer* dataOut)
         ////////////////////////////////////////////////////////////////
         // Processing FIC
         ////////////////////////////////////////////////////////////////
-        FicSource* fic = myEtiReader.getFic();
-        PrbsGenerator* ficPrbs = NULL;
-        ConvEncoder* ficConv = NULL;
-        PuncturingEncoder* ficPunc = NULL;
+        shared_ptr<FicSource> fic(myEtiReader.getFic());
         ////////////////////////////////////////////////////////////////
         // Data initialisation
         ////////////////////////////////////////////////////////////////
@@ -241,13 +244,13 @@ int DabModulator::process(Buffer* const dataIn, Buffer* dataOut)
         PDEBUG(" Framesize: %zu\n", fic->getFramesize());
 
         // Configuring prbs generator
-        ficPrbs = new PrbsGenerator(myFicSizeIn, 0x110);
+        shared_ptr<PrbsGenerator> ficPrbs(new PrbsGenerator(myFicSizeIn, 0x110));
 
         // Configuring convolutionnal encoder
-        ficConv = new ConvEncoder(myFicSizeIn);
+        shared_ptr<ConvEncoder> ficConv(new ConvEncoder(myFicSizeIn));
 
         // Configuring puncturing encoder
-        ficPunc = new PuncturingEncoder();
+        shared_ptr<PuncturingEncoder> ficPunc(new PuncturingEncoder());
         std::vector<PuncturingRule*> rules = fic->get_rules();
         std::vector<PuncturingRule*>::const_iterator rule;
         for (rule = rules.begin(); rule != rules.end(); ++rule) {
@@ -267,16 +270,12 @@ int DabModulator::process(Buffer* const dataIn, Buffer* dataOut)
         ////////////////////////////////////////////////////////////////
         // Configuring subchannels
         ////////////////////////////////////////////////////////////////
-        std::vector<SubchannelSource*> subchannels =
+        std::vector<shared_ptr<SubchannelSource> > subchannels =
             myEtiReader.getSubchannels();
-        std::vector<SubchannelSource*>::const_iterator subchannel;
+        std::vector<shared_ptr<SubchannelSource> >::const_iterator subchannel;
         for (subchannel = subchannels.begin();
                 subchannel != subchannels.end();
                 ++subchannel) {
-            PrbsGenerator* subchPrbs = NULL;
-            ConvEncoder* subchConv = NULL;
-            PuncturingEncoder* subchPunc = NULL;
-            TimeInterleaver* subchInterleaver = NULL;
 
             ////////////////////////////////////////////////////////////
             // Data initialisation
@@ -307,13 +306,17 @@ int DabModulator::process(Buffer* const dataIn, Buffer* dataOut)
                     (*subchannel)->protectionOption());
 
             // Configuring prbs genrerator
-            subchPrbs = new PrbsGenerator(subchSizeIn, 0x110);
+            shared_ptr<PrbsGenerator> subchPrbs(
+                    new PrbsGenerator(subchSizeIn, 0x110));
 
             // Configuring convolutionnal encoder
-            subchConv = new ConvEncoder(subchSizeIn);
+            shared_ptr<ConvEncoder> subchConv(
+                    new ConvEncoder(subchSizeIn));
 
             // Configuring puncturing encoder
-            subchPunc = new PuncturingEncoder();
+            shared_ptr<PuncturingEncoder> subchPunc(
+                    new PuncturingEncoder());
+
             std::vector<PuncturingRule*> rules = (*subchannel)->get_rules();
             std::vector<PuncturingRule*>::const_iterator rule;
             for (rule = rules.begin(); rule != rules.end(); ++rule) {
@@ -326,7 +329,8 @@ int DabModulator::process(Buffer* const dataIn, Buffer* dataOut)
             subchPunc->append_tail_rule(PuncturingRule(3, 0xcccccc));
 
             // Configuring time interleaver
-            subchInterleaver = new TimeInterleaver(subchSizeOut);
+            shared_ptr<TimeInterleaver> subchInterleaver(
+                    new TimeInterleaver(subchSizeOut));
 
             myFlowgraph->connect(*subchannel, subchPrbs);
             myFlowgraph->connect(subchPrbs, subchConv);
@@ -342,7 +346,7 @@ int DabModulator::process(Buffer* const dataIn, Buffer* dataOut)
         myFlowgraph->connect(cifFreq, cifDiff);
         myFlowgraph->connect(cifNull, cifSig);
         myFlowgraph->connect(cifDiff, cifSig);
-        if (myClockRate) {
+        if (myClockRate) { // TODO review
             myFlowgraph->connect(cifSig, cifCicEq);
             myFlowgraph->connect(cifCicEq, cifOfdm);
         } else {
@@ -352,18 +356,21 @@ int DabModulator::process(Buffer* const dataIn, Buffer* dataOut)
         myFlowgraph->connect(cifGain, cifGuard);
 
         if (myFilterTapsFilename != "") {
-            myFlowgraph->connect(cifGuard, cifFilter);
+            shared_ptr<FIRFilter> cifFilterptr(cifFilter);
+            myFlowgraph->connect(cifGuard, cifFilterptr);
             if (cifRes != NULL) {
-                myFlowgraph->connect(cifFilter, cifRes);
-                myFlowgraph->connect(cifRes, myOutput);
+                shared_ptr<Resampler> res(cifRes);
+                myFlowgraph->connect(cifFilterptr, res);
+                myFlowgraph->connect(res, myOutput);
             } else {
-                myFlowgraph->connect(cifFilter, myOutput);
+                myFlowgraph->connect(cifFilterptr, myOutput);
             }
         }
         else { //no filtering
             if (cifRes != NULL) {
-                myFlowgraph->connect(cifGuard, cifRes);
-                myFlowgraph->connect(cifRes, myOutput);
+                shared_ptr<Resampler> res(cifRes);
+                myFlowgraph->connect(cifGuard, res);
+                myFlowgraph->connect(res, myOutput);
             } else {
                 myFlowgraph->connect(cifGuard, myOutput);
             }
@@ -374,6 +381,6 @@ int DabModulator::process(Buffer* const dataIn, Buffer* dataOut)
     ////////////////////////////////////////////////////////////////////
     // Proccessing data
     ////////////////////////////////////////////////////////////////////
-    myOutput->setOutput(dataOut);
     return myFlowgraph->run();
 }
+
diff --git a/src/DabModulator.h b/src/DabModulator.h
index 84c9926..89ddd7c 100644
--- a/src/DabModulator.h
+++ b/src/DabModulator.h
@@ -3,8 +3,10 @@
    Her Majesty the Queen in Right of Canada (Communications Research
    Center Canada)
 
-   Includes modifications for which no copyright is claimed
-   2012, Matthias P. Braendli, matthias.braendli@mpb.li
+   Copyright (C) 2015
+   Matthias P. Braendli, matthias.braendli@mpb.li
+
+    http://opendigitalradio.org
  */
 /*
    This file is part of ODR-DabMod.
@@ -32,6 +34,7 @@
 
 #include <sys/types.h>
 #include <string>
+#include <boost/shared_ptr.hpp>
 
 #include "ModCodec.h"
 #include "EtiReader.h"
@@ -88,5 +91,5 @@ protected:
     size_t myFicSizeIn;
 };
 
-
 #endif // DAB_MODULATOR_H
+
diff --git a/src/EtiReader.cpp b/src/EtiReader.cpp
index fe54f55..7e0df72 100644
--- a/src/EtiReader.cpp
+++ b/src/EtiReader.cpp
@@ -2,7 +2,7 @@
    Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011 Her Majesty
    the Queen in Right of Canada (Communications Research Center Canada)
 
-   Copyright (C) 2014
+   Copyright (C) 2014, 2015
    Matthias P. Braendli, matthias.braendli@mpb.li
 
     http://opendigitalradio.org
@@ -34,6 +34,7 @@
 #include <string.h>
 #include <arpa/inet.h>
 
+using namespace boost;
 
 enum ETI_READER_STATE {
     EtiReaderStateNbFrame,
@@ -69,9 +70,6 @@ EtiReader::~EtiReader()
 //    if (myFicSource != NULL) {
 //        delete myFicSource;
 //    }
-//    for (unsigned i = 0; i < mySources.size(); ++i) {
-//        delete mySources[i];
-//    }
 }
 
 
@@ -93,13 +91,13 @@ unsigned EtiReader::getFp()
 }
 
 
-const std::vector<SubchannelSource*>& EtiReader::getSubchannels()
+const std::vector<boost::shared_ptr<SubchannelSource> >& EtiReader::getSubchannels()
 {
     return mySources;
 }
 
 
-int EtiReader::process(Buffer* dataIn)
+int EtiReader::process(const Buffer* dataIn)
 {
     PDEBUG("EtiReader::process(dataIn: %p)\n", dataIn);
     PDEBUG(" state: %u\n", state);
@@ -171,13 +169,12 @@ int EtiReader::process(Buffer* dataIn)
                     (memcmp(&eti_stc[0], in, 4 * eti_fc.NST))) {
                 PDEBUG("New stc!\n");
                 eti_stc.resize(eti_fc.NST);
-                for (unsigned i = 0; i < mySources.size(); ++i) {
-                    delete mySources[i];
-                }
-                mySources.resize(eti_fc.NST);
                 memcpy(&eti_stc[0], in, 4 * eti_fc.NST);
+
+                mySources.clear();
                 for (unsigned i = 0; i < eti_fc.NST; ++i) {
-                    mySources[i] = new SubchannelSource(eti_stc[i]);
+                    mySources.push_back(shared_ptr<SubchannelSource>(
+                                new SubchannelSource(eti_stc[i])));
                     PDEBUG("Sstc %u:\n", i);
                     PDEBUG(" Stc%i.scid: %i\n", i, eti_stc[i].SCID);
                     PDEBUG(" Stc%i.sad: %u\n", i, eti_stc[i].getStartAddress());
diff --git a/src/EtiReader.h b/src/EtiReader.h
index 209b208..136bd1c 100644
--- a/src/EtiReader.h
+++ b/src/EtiReader.h
@@ -2,7 +2,7 @@
    Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011 Her Majesty
    the Queen in Right of Canada (Communications Research Center Canada)
 
-   Copyright (C) 2014
+   Copyright (C) 2014, 2015
    Matthias P. Braendli, matthias.braendli@mpb.li
 
     http://opendigitalradio.org
@@ -41,6 +41,7 @@
 #include <vector>
 #include <stdint.h>
 #include <sys/types.h>
+#include <boost/shared_ptr.hpp>
 
 
 class EtiReader
@@ -54,8 +55,8 @@ public:
     FicSource* getFic();
     unsigned getMode();
     unsigned getFp();
-    const std::vector<SubchannelSource*>& getSubchannels();
-    int process(Buffer* dataIn);
+    const std::vector<boost::shared_ptr<SubchannelSource> >& getSubchannels();
+    int process(const Buffer* dataIn);
 
     void calculateTimestamp(struct frame_timestamp& ts)
     {
@@ -83,9 +84,9 @@ protected:
     eti_EOF eti_eof;
     eti_TIST eti_tist;
     FicSource* myFicSource;
-    std::vector<SubchannelSource*> mySources;
+    std::vector<boost::shared_ptr<SubchannelSource> > mySources;
     TimestampDecoder myTimestampDecoder;
-    
+
 private:
     size_t myCurrentFrame;
     bool time_ext_enabled;
@@ -94,3 +95,4 @@ private:
 
 
 #endif // ETI_READER_H
+
diff --git a/src/Flowgraph.cpp b/src/Flowgraph.cpp
index 373533b..22f604b 100644
--- a/src/Flowgraph.cpp
+++ b/src/Flowgraph.cpp
@@ -1,6 +1,11 @@
 /*
    Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011 Her Majesty
    the Queen in Right of Canada (Communications Research Center Canada)
+
+   Copyright (C) 2015
+   Matthias P. Braendli, matthias.braendli@mpb.li
+
+    http://opendigitalradio.org
  */
 /*
    This file is part of ODR-DabMod.
@@ -38,19 +43,18 @@
 #include <sys/time.h>
 #endif
 
-#include <boost/shared_ptr.hpp>
-
 using namespace boost;
 
 typedef std::vector<shared_ptr<Node> >::iterator NodeIterator;
 typedef std::vector<shared_ptr<Edge> >::iterator EdgeIterator;
 
 
-Node::Node(ModPlugin* plugin) :
+Node::Node(shared_ptr<ModPlugin> plugin) :
     myPlugin(plugin),
     myProcessTime(0)
 {
-    PDEBUG("Node::Node(plugin(%s): %p) @ %p\n", plugin->name(), plugin, this);
+    PDEBUG("Node::Node(plugin(%s): %p) @ %p\n",
+            plugin->name(), plugin.get(), this);
 
 }
 
@@ -59,9 +63,6 @@ Node::~Node()
 {
     PDEBUG("Node::~Node() @ %p\n", this);
 
-    if (myPlugin != NULL) {
-        delete myPlugin;
-    }
     assert(myInputBuffers.size() == 0);
     assert(myOutputBuffers.size() == 0);
 }
@@ -72,8 +73,8 @@ Edge::Edge(shared_ptr<Node>& srcNode, shared_ptr<Node>& dstNode) :
     myDstNode(dstNode)
 {
     PDEBUG("Edge::Edge(srcNode(%s): %p, dstNode(%s): %p) @ %p\n",
-            srcNode->plugin()->name(), srcNode,
-            dstNode->plugin()->name(), dstNode,
+            srcNode->plugin()->name(), srcNode.get(),
+            dstNode->plugin()->name(), dstNode.get(),
             this);
 
     myBuffer = shared_ptr<Buffer>(new Buffer());
@@ -112,7 +113,7 @@ Edge::~Edge()
 int Node::process()
 {
     PDEBUG("Edge::process()\n");
-    PDEBUG(" Plugin name: %s (%p)\n", myPlugin->name(), myPlugin);
+    PDEBUG(" Plugin name: %s (%p)\n", myPlugin->name(), myPlugin.get());
 
     // the plugin process() still wants vector<Buffer*>
     // arguments.
@@ -165,11 +166,10 @@ Flowgraph::~Flowgraph()
     }
 }
 
-
-void Flowgraph::connect(ModPlugin* input, ModPlugin* output)
+void Flowgraph::connect(shared_ptr<ModPlugin> input, shared_ptr<ModPlugin> output)
 {
     PDEBUG("Flowgraph::connect(input(%s): %p, output(%s): %p)\n",
-            input->name(), input, output->name(), output);
+            input->name(), input.get(), output->name(), output.get());
 
     NodeIterator inputNode;
     NodeIterator outputNode;
@@ -237,3 +237,4 @@ bool Flowgraph::run()
     }
     return true;
 }
+
diff --git a/src/Flowgraph.h b/src/Flowgraph.h
index 00b8d42..1129668 100644
--- a/src/Flowgraph.h
+++ b/src/Flowgraph.h
@@ -1,6 +1,11 @@
 /*
    Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011 Her Majesty
    the Queen in Right of Canada (Communications Research Center Canada)
+
+   Copyright (C) 2015
+   Matthias P. Braendli, matthias.braendli@mpb.li
+
+    http://opendigitalradio.org
  */
 /*
    This file is part of ODR-DabMod.
@@ -38,12 +43,12 @@
 class Node
 {
 public:
-    Node(ModPlugin* plugin);
+    Node(boost::shared_ptr<ModPlugin> plugin);
     ~Node();
     Node(const Node&);
     Node& operator=(const Node&);
 
-    ModPlugin* plugin() { return myPlugin; }
+    boost::shared_ptr<ModPlugin> plugin() { return myPlugin; }
 
     std::vector<boost::shared_ptr<Buffer> > myInputBuffers;
     std::vector<boost::shared_ptr<Buffer> > myOutputBuffers;
@@ -55,7 +60,7 @@ public:
     }
 
 protected:
-    ModPlugin* myPlugin;
+    boost::shared_ptr<ModPlugin> myPlugin;
     time_t myProcessTime;
 };
 
@@ -83,7 +88,8 @@ public:
     Flowgraph(const Flowgraph&);
     Flowgraph& operator=(const Flowgraph&);
 
-    void connect(ModPlugin* input, ModPlugin* output);
+    void connect(boost::shared_ptr<ModPlugin> input,
+                 boost::shared_ptr<ModPlugin> output);
     bool run();
 
 protected:
diff --git a/src/FrameMultiplexer.cpp b/src/FrameMultiplexer.cpp
index c5e58b7..843f72d 100644
--- a/src/FrameMultiplexer.cpp
+++ b/src/FrameMultiplexer.cpp
@@ -30,8 +30,11 @@
 
 typedef std::complex<float> complexf;
 
+using namespace boost;
 
-FrameMultiplexer::FrameMultiplexer(size_t framesize, const std::vector<SubchannelSource*>* subchannels) :
+FrameMultiplexer::FrameMultiplexer(
+        size_t framesize,
+        const std::vector<shared_ptr<SubchannelSource> >* subchannels) :
     ModMux(ModFormat(framesize), ModFormat(framesize)),
     d_frameSize(framesize),
     mySubchannels(subchannels)
@@ -76,7 +79,7 @@ int FrameMultiplexer::process(std::vector<Buffer*> dataIn, Buffer* dataOut)
     ++in;
     // Write subchannel
     assert(mySubchannels->size() == dataIn.size() - 1);
-    std::vector<SubchannelSource*>::const_iterator subchannel =
+    std::vector<shared_ptr<SubchannelSource> >::const_iterator subchannel =
         mySubchannels->begin();
     while (in != dataIn.end()) {
         assert((*subchannel)->framesizeCu() * 8 == (*in)->getLength());
@@ -88,3 +91,4 @@ int FrameMultiplexer::process(std::vector<Buffer*> dataIn, Buffer* dataOut)
 
     return dataOut->getLength();
 }
+
diff --git a/src/FrameMultiplexer.h b/src/FrameMultiplexer.h
index f1bd587..ba571f6 100644
--- a/src/FrameMultiplexer.h
+++ b/src/FrameMultiplexer.h
@@ -29,7 +29,7 @@
 
 #include "ModMux.h"
 #include "SubchannelSource.h"
-
+#include <boost/shared_ptr.hpp>
 
 #include <sys/types.h>
 
@@ -37,7 +37,8 @@
 class FrameMultiplexer : public ModMux
 {
 public:
-    FrameMultiplexer(size_t frameSize, const std::vector<SubchannelSource*>* subchannels);
+    FrameMultiplexer(size_t frameSize,
+            const std::vector<boost::shared_ptr<SubchannelSource> >* subchannels);
     virtual ~FrameMultiplexer();
     FrameMultiplexer(const FrameMultiplexer&);
     FrameMultiplexer& operator=(const FrameMultiplexer&);
@@ -48,8 +49,8 @@ public:
 
 protected:
     size_t d_frameSize;
-    const std::vector<SubchannelSource*>* mySubchannels;
+    const std::vector<boost::shared_ptr<SubchannelSource> >* mySubchannels;
 };
 
-
 #endif // FRAME_MULTIPLEXER_H
+
diff --git a/src/OutputMemory.h b/src/OutputMemory.h
index 2dd49c5..56cbc01 100644
--- a/src/OutputMemory.h
+++ b/src/OutputMemory.h
@@ -50,7 +50,7 @@
 class OutputMemory : public ModOutput
 {
 public:
-    OutputMemory(Buffer* dataOut = NULL);
+    OutputMemory(Buffer* dataOut);
     virtual ~OutputMemory();
     virtual int process(Buffer* dataIn, Buffer* dataOut);
     const char* name() { return "OutputMemory"; }