view sv/filter/FilterStack.cpp @ 282:d9319859a4cf tip

(none)

/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */

/*	Sound Access	
		EASAIER client application.	
		Silogic 2007. Laure Bajard. 
	
	This program is free software; you can redistribute it and/or    
	modify it under the terms of the GNU General Public License as    
	published by the Free Software Foundation; either version 2 of the    
	License, or (at your option) any later version.  See the file    
	COPYING included with this distribution for more information.
*/
 
#include "FilterStack.h"

#include "MultiRealTimeFilter.h"

FilterStack::FilterStack() : QObject(),
	m_count(0),
	m_sourceChannelCount(0)
{}

FilterStack::~FilterStack()
{
	removeAllFilters();
}

Filter* FilterStack::findFilter(QString &name)
{
	std::map<int, Filter *>::iterator iter;

	for ( iter = m_filters.begin(); iter != m_filters.end(); iter++) 
	{
		Filter * filter = iter->second;
		if (name.contains(filter->objectName())) 
		{
			return filter;
		}
    }
	return 0;
}

void FilterStack::addFilter(Filter * filter)
{
	m_filters[m_count] = filter;
	filter->setSourceChannelCount(m_sourceChannelCount);
	m_count++;	

	std::vector<PropertyContainer*> filterCollection = filter->getFilterCollection();
	std::vector<PropertyContainer*>::iterator iter;
	for (iter = filterCollection.begin(); iter != filterCollection.end(); iter++)
	{
		PropertyContainer* filterElt = *iter;
		emit newFilterAdded(filterElt);
	}

	connect(filter, SIGNAL(propertyContainerRemoved(QString)),
            this, SIGNAL(filterRemoved(QString)));
}

void FilterStack::putInput(float **input, size_t samples)
{
	//only process the first filter, should pass in all filters !!!
	std::map<int, Filter *>::iterator iter = m_filters.begin();

	if (iter != m_filters.end())
	{
		Filter * filter = iter->second;
		if(filter->isFilterEnabled()){
			filter->putInput(input, samples);
		}
	}
}

void FilterStack::getOutput(float **output, size_t samples)
{
	//only process the first filter, should pass in all filters !!!
	std::map<int, Filter *>::iterator iter = m_filters.begin();

	if (iter != m_filters.end())
	{
		Filter * filter = iter->second;
		if(filter->isFilterEnabled()){
			filter->getOutput(output, samples);
		}
	}
}

QString FilterStack::getUniqueFilterName(QString candidate)
{
    for (int count = 1; ; ++count) {

        QString adjusted =
            (count > 1 ? QString("%1 <%2>").arg(candidate).arg(count) :
             candidate);
        
        bool duplicate = false;

        for (std::map<int, Filter *>::iterator i = m_filters.begin(); i != m_filters.end(); ++i) {
			Filter * filter = i->second;
			if (filter->objectName() == adjusted) {
                duplicate = true;
                break;
            }
        }

        if (!duplicate) return adjusted;
    }
}

void FilterStack::removeFilter(QString &name)
{
	std::map<int, Filter *>::iterator iter;

	for (iter = m_filters.begin(); iter != m_filters.end(); iter++)
	{
		Filter * filter = iter->second;
		if (filter->objectName() == name)
		{
			delete filter;
			m_filters.erase(iter);
			emit filterRemoved(name);
			filter = 0;
			return;
		}
	}
}

void FilterStack::removeAllFilters()
{
	while (!m_filters.empty())
	{
		Filter * filter = m_filters.begin()->second;
		QString filterName(filter->objectName());
		removeFilter(filterName);
	}
	m_filters.clear();
	m_count = 0;
}

size_t FilterStack::getRequiredInputSamples(size_t outputSamplesNeeded)
{
	size_t max = 0;

	std::map<int, Filter *>::iterator iter;

	for (iter = m_filters.begin(); iter != m_filters.end(); iter++)
	{
		Filter * filter = iter->second;
		size_t required = filter->getRequiredInputSamples(outputSamplesNeeded);
		if ( (required > max) && (filter->isFilterEnabled()) )
		{
			max = required;
		}
	}
	return max;
}

size_t FilterStack::getRequiredSkipSamples()
{
	size_t skip = 1024;

	std::map<int, Filter *>::iterator iter;

	for (iter = m_filters.begin(); iter != m_filters.end(); iter++)
	{
		// find the time filter
		Filter * filter = iter->second;
		if (filter->objectName() == "DIT Filters")
		{
			MultiRealTimeFilter * timefilter = (MultiRealTimeFilter *) filter;
			if (filter->isFilterEnabled()) {
				skip = timefilter->getRequiredSkipSamples();
			}
		}
	}
	return skip;
}

void FilterStack::setSourceChannelCount(size_t channel)
{
	m_sourceChannelCount = channel;

	std::map<int, Filter *>::iterator iter;

	for (iter = m_filters.begin(); iter != m_filters.end(); iter++)
	{
		Filter * filter = iter->second;
		filter->setSourceChannelCount(m_sourceChannelCount);
	}

}

bool FilterStack::allowOtherFilter(QString &labelType)
{
	Filter* filter = findFilter(labelType);
	if ( (filter) && (!filter->allowMultiple()) )
	{
		return false;
	}

	return true;
}

QString FilterStack::toEasaierXmlString(QString indent, QString extraAttributes) const
{
    QString s;

    s += indent + QString("<filters>\n");

	std::map<int, Filter *>::const_iterator iter;
	for (iter = m_filters.begin(); iter != m_filters.end(); iter++)
	{
		Filter * filter = iter->second;
		s += filter->toEasaierXmlString(indent + indent, extraAttributes);
	}

    s += indent + "</filters>\n";

    return s;
}