void textract_trainAccumulator(string sfName, mrs_natural offset, mrs_natural duration, mrs_real start, mrs_real length, mrs_real gain, mrs_natural label, string pluginName, string wekafname, mrs_natural memSize, string extractorStr, TimeLine& tline)
{
	MarSystemManager mng;

	MRSDIAG("sfplay.cpp - sfplay");

	// default 
	if (extractorStr == EMPTYSTRING) 
		extractorStr = "STFT";

	// Find proper soundfile format and create SignalSource 
	MarSystem *src = mng.create("SoundFileSource", "src");

	src->updctrl("mrs_string/filename", sfName);
	src->updctrl("mrs_natural/inSamples", MRS_DEFAULT_SLICE_NSAMPLES);

	if (tlineName == EMPTYSTRING)
	{
		mrs_natural hops = src->getctrl("mrs_natural/size")->to<mrs_natural>() * src->getctrl("mrs_natural/nChannels")->to<mrs_natural>() / 2048 + 1;
		tline.regular(100, hops);
	}

	MarSystem *dest_;
	dest_ = mng.create("AudioSink", "dest");

	MarSystem *series = mng.create("Series", "playbacknet");
	series->addMarSystem(src);
	series->addMarSystem(dest_);

	series->updctrl("AudioSink/dest/mrs_natural/nChannels", 
		series->getctrl("SoundFileSource/src/mrs_natural/nChannels")->to<mrs_natural>());  

	// Calculate duration, offset parameters if necessary 
	if (start > 0.0f) 
		offset = (mrs_natural) (start 
		* src->getctrl("mrs_real/israte")->to<mrs_real>() 
		* src->getctrl("mrs_natural/nChannels")->to<mrs_natural>());
	if (length != 30.0f) 
		duration = (mrs_natural) (length 
		* src->getctrl("mrs_real/israte")->to<mrs_real>() 
		* src->getctrl("mrs_natural/nChannels")->to<mrs_natural>());

	// accumulate feature vectors over 30 seconds 
	MarSystem* acc = mng.create("Accumulator", "acc");

	acc->updctrl("mrs_natural/nTimes", 100);

	// Calculate windowed power spectrum and then 
	// calculate specific feature sets 
	MarSystem* spectralShape = mng.create("Series", "spectralShape");
	spectralShape->addMarSystem(mng.create("Windowing", "hamming"));
	spectralShape->addMarSystem(mng.create("Spectrum","spk"));
	spectralShape->addMarSystem(mng.create("PowerSpectrum", "pspk"));
	spectralShape->updctrl("PowerSpectrum/pspk/mrs_string/spectrumType","power");  

	// Spectrum Shape descriptors
	MarSystem* spectrumFeatures = mng.create("Fanout", "spectrumFeatures");

	if (extractorStr == "STFT") 
	{
		spectrumFeatures->addMarSystem(mng.create("Centroid", "cntrd"));
		spectrumFeatures->addMarSystem(mng.create("Rolloff", "rlf"));      
		spectrumFeatures->addMarSystem(mng.create("Flux", "flux"));
	}
	else if (extractorStr == "STFTMFCC")
	{
		spectrumFeatures->addMarSystem(mng.create("Centroid", "cntrd"));
		spectrumFeatures->addMarSystem(mng.create("Rolloff", "rlf"));      
		spectrumFeatures->addMarSystem(mng.create("Flux", "flux"));
		spectrumFeatures->addMarSystem(mng.create("MFCC", "mfcc"));
	}
	else if (extractorStr == "MFCC")
		spectrumFeatures->addMarSystem(mng.create("MFCC", "mfcc"));
	else if (extractorStr == "SCF")
		spectrumFeatures->addMarSystem(mng.create("SCF", "scf"));
	else if (extractorStr == "SFM") 
		spectrumFeatures->addMarSystem(mng.create("SFM", "sfm"));

	mng.registerPrototype("SpectrumFeatures", spectrumFeatures->clone());
	spectralShape->addMarSystem(mng.create("SpectrumFeatures", "spectrumFeatures"));
	mng.registerPrototype("SpectralShape", spectralShape->clone());

	//  add time-domain zerocrossings
	MarSystem* features = mng.create("Fanout", "features");
	features->addMarSystem(mng.create("SpectralShape", "SpectralShape"));
	if (extractorStr == "STFT")
		features->addMarSystem(mng.create("ZeroCrossings", "zcrs"));      
	mng.registerPrototype("Features", features->clone());

	// Means and standard deviation (statistics) for texture analysis 
	MarSystem* statistics = mng.create("Fanout","statistics");
	statistics->addMarSystem(mng.create("Mean", "mn"));
	statistics->addMarSystem(mng.create("StandardDeviation", "std"));
	mng.registerPrototype("Statistics", statistics->clone());

	// weka output 
	MarSystem *wsink = mng.create("WekaSink","wsink");

	// Build the overall feature calculation network 
	MarSystem* featureNetwork = mng.create("Series", "featureNetwork");

	featureNetwork->addMarSystem(src->clone());
	featureNetwork->addMarSystem(mng.create("Features", "features"));
	featureNetwork->addMarSystem(mng.create("Memory", "memory"));
	featureNetwork->updctrl("Memory/memory/mrs_natural/memSize", memSize);
	featureNetwork->addMarSystem(mng.create("Statistics", "statistics"));  

	// add network to accumulator
	acc->addMarSystem(featureNetwork->clone());

	// Final network compute 30-second statistics 
	MarSystem* total = mng.create("Series", "total");
	total->addMarSystem(acc->clone());
	total->addMarSystem(mng.create("Statistics", "statistics2"));
	// total->addMarSystem(mng.create("Mean", "mn2"));
	total->addMarSystem(wsink->clone());

	// update controls 
	total->updctrl("mrs_natural/inSamples", MRS_DEFAULT_SLICE_NSAMPLES);
	total->updctrl("Accumulator/acc/Series/featureNetwork/" + src->getType() + "/src/mrs_natural/pos", offset);      

	mrs_natural wc = 0;
	mrs_natural samplesPlayed =0;

	// main loop for extracting the features 
	string className = "";

	total->updctrl("Accumulator/acc/Series/featureNetwork/SoundFileSource/src/mrs_string/filename", sfName);
	wc = 0;  	  
	samplesPlayed = 0;

	total->updctrl("WekaSink/wsink/mrs_natural/nLabels", (mrs_natural)3);
	if (wekafname == EMPTYSTRING) 
		total->updctrl("WekaSink/wsink/mrs_string/filename", "weka2.arff");
	else 
		total->updctrl("WekaSink/wsink/mrs_string/filename", wekafname);  

	// total->tick();

	for (int r = 0; r < tline.numRegions(); r++)
	{
		cout << "start = " << tline.regionStart(r) << endl;
		cout << "end = " << tline.regionEnd(r) << endl;

		total->updctrl("Accumulator/acc/Series/featureNetwork/SoundFileSource/src/mrs_natural/pos", (mrs_natural)tline.regionStart(r) * tline.lineSize());
		total->updctrl("mrs_natural/inSamples", tline.lineSize());
		if (tlineName == EMPTYSTRING)
		{
			if ((tline.regionClass(r) > 0) && (tline.regionClass(r) != 4))//[?]
			{
				total->updctrl("WekaSink/wsink/mrs_natural/label", tline.regionClass(r)-1);
			}
		}
		else
			total->tick();
	}

	if (pluginName == EMPTYSTRING) // output to stdout 
		cout << (*total) << endl;      
	else 
	{
		ofstream oss(pluginName.c_str());
		oss << (*total) << endl;
	}
}