/**
Energy changed handler
*/
void Filter_EnergyChanged(Message message) {
MessageEnergyChanged* m;
m = (MessageEnergyChanged*) message;
if (m->over_threshold) {
DEBUG_FILTER(("[FILTER] VOICE_ACTIVITY_ON\n"));
voice_activity = VOICE_ACTIVITY_ON;
} else {
DEBUG_FILTER(("[FILTER] VOICE_ACTIVITY_OFF\n"));
voice_activity = VOICE_ACTIVITY_OFF;
}
set_filter();
}
/* cpp_filter_inject */
static int _cpp_filter_inject(int * c, void * data)
{
CppParser * cp = data;
size_t len;
int d;
if(cp->inject == NULL)
return 0;
DEBUG_FILTER();
if((len = strlen(cp->inject)) > 0)
{
d = *c;
*c = cp->inject[0];
memmove(cp->inject, &cp->inject[1], len--);
if(cp->inject_first && d != EOF && d != '\0')
{
cp->inject[len++] = d;
cp->inject[len] = '\0';
cp->inject_first = 0;
}
}
if(len > 0)
return 1;
free(cp->inject);
cp->inject = NULL;
return 0;
}
/**
Switch Off the wind noise filter
*/
void Filter_Off(void)
{
DEBUG_FILTER(("[FILTER] OFF\n"));
CodecSetIIRFilterA(FALSE, theHeadset.conf->filter.coefficients);
CodecSetIIRFilterB(FALSE, theHeadset.conf->filter.coefficients);
EnergyEstimationOff(theHeadset.sco_sink);
}
/**
Switch On the wind noise filter
*/
void Filter_On(void)
{
DEBUG_FILTER(("[FILTER] ON\n"));
MessageSinkTask(theHeadset.sco_sink, &theHeadset.task);
voice_activity = VOICE_ACTIVITY_OFF;
set_filter();
}
bool CPluginFilter::AddFilterElementHide(std::wstring filterText)
{
DEBUG_FILTER(L"Input: " + filterText + L" filterFile" + filterFile);
CriticalSection::Lock filterEngineLock(s_criticalSectionFilterMap);
{
// Create filter descriptor
std::auto_ptr<CFilterElementHide> filter;
wchar_t separatorChar;
do
{
auto chunkEnd = filterText.find_first_of(L"+>");
if (chunkEnd != std::wstring::npos && chunkEnd > 0)
{
separatorChar = filterText[chunkEnd];
}
else
{
chunkEnd = filterText.length();
separatorChar = L'\0';
}
std::auto_ptr<CFilterElementHide> filterParent(filter);
filter.reset(new CFilterElementHide(TrimStringRight(filterText.substr(0, chunkEnd))));
if (filterParent.get() != 0)
{
filter->m_predecessor.reset(filterParent.release());
}
if (separatorChar != L'\0') // complex selector
{
filterText = TrimStringLeft(filterText.substr(chunkEnd + 1));
if (separatorChar == '+')
filter->m_type = CFilterElementHide::TRAVERSER_TYPE_IMMEDIATE;
else if (separatorChar == '>')
filter->m_type = CFilterElementHide::TRAVERSER_TYPE_PARENT;
}
else // Terminating element (simple selector)
{
if (!filter->m_tagId.empty())
{
m_elementHideTagsId.insert(std::make_pair(std::make_pair(filter->m_tag, filter->m_tagId), *filter));
}
else if (!filter->m_tagClassName.empty())
{
m_elementHideTagsClass.insert(std::make_pair(std::make_pair(filter->m_tag, filter->m_tagClassName), *filter));
}
else
{
m_elementHideTags.insert(std::make_pair(filter->m_tag, *filter));
}
}
} while (separatorChar != '\0');
}
return true;
}
CFilterElementHide::CFilterElementHide(const CString& filterText) : m_filterText(filterText), m_type(ETraverserComplexType::TRAVERSER_TYPE_ERROR)
{
// Find tag name, class or any (*)
CString filterString = filterText;
wchar_t firstTag = filterString.GetAt(0);
// Any tag
if (firstTag == '*')
{
filterString = filterString.Mid(1);
}
// Any tag (implicitely)
else if (firstTag == '[' || firstTag == '.' || firstTag == '#')
{
}
// Real tag
else if (isalnum(firstTag))
{
//TODO: Add support for descendant selectors
int pos = filterString.FindOneOf(L".#[(");
if (pos < 0)
pos = filterString.GetLength();
m_tag = filterString.Left(pos).MakeLower();
filterString = filterString.Mid(pos);
}
// Error
else
{
DEBUG_FILTER("Filter::Error parsing selector:" + filterText + " (invalid tag)");
throw std::runtime_error(CStringA("Filter::Error parsing selector:" + filterText + " (invalid tag)").GetString());
}
// Find Id and class name
if (!filterString.IsEmpty())
{
wchar_t firstId = filterString.GetAt(0);
// Id
if (firstId == '#')
{
int pos = filterString.Find('[');
if (pos < 0)
{
pos = filterString.GetLength();
}
m_tagId = filterString.Mid(1, pos - 1);
filterString = filterString.Mid(pos);
pos = m_tagId.Find(L".");
if (pos > 0)
{
m_tagClassName = m_tagId.Mid(pos + 1);
m_tagId = m_tagId.Left(pos);
}
}
// Class name
else if (firstId == '.')
{
int pos = filterString.Find('[');
if (pos < 0)
{
pos = filterString.GetLength();
}
m_tagClassName = filterString.Mid(1, pos - 1);
filterString = filterString.Mid(pos);
}
}
char chAttrStart = '[';
char chAttrEnd = ']';
while (!filterString.IsEmpty())
{
if (filterString.GetAt(0) != chAttrStart)
{
DEBUG_FILTER("Filter::Error parsing selector:" + filterText + " (more data)");
throw std::runtime_error(CStringA("Filter::Error parsing selector:" + filterText + " (more data)").GetString());
}
int endPos = filterString.Find(']') ;
if (endPos < 0)
{
DEBUG_FILTER("Filter::Error parsing selector:" + filterText + " (more data)");
throw std::runtime_error(CStringA("Filter::Error parsing selector:" + filterText + " (more data)").GetString());
}
CFilterElementHideAttrSelector attrSelector;
CString arg = filterString.Mid(1, endPos - 1);
filterString = filterString.Mid(endPos + 1);
int delimiterPos = arg.Find('=');
if (delimiterPos > 0)
{
attrSelector.m_value = arg.Mid(delimiterPos + 1);
if (attrSelector.m_value.GetLength() >= 2 && attrSelector.m_value.GetAt(0) == '\"' && attrSelector.m_value.GetAt(attrSelector.m_value.GetLength() - 1) == '\"')
{
attrSelector.m_value = attrSelector.m_value.Mid(1, attrSelector.m_value.GetLength() - 2);
}
if (arg.GetAt(delimiterPos - 1) == '^')
{
attrSelector.m_bstrAttr = arg.Left(delimiterPos - 1);
attrSelector.m_pos = CFilterElementHideAttrPos::STARTING;
}
else if (arg.GetAt(delimiterPos - 1) == '*')
{
attrSelector.m_bstrAttr = arg.Left(delimiterPos - 1);
attrSelector.m_pos = CFilterElementHideAttrPos::ANYWHERE;
}
else if (arg.GetAt(delimiterPos - 1) == '$')
{
attrSelector.m_bstrAttr = arg.Left(delimiterPos - 1);
attrSelector.m_pos = CFilterElementHideAttrPos::ENDING;
}
else
{
attrSelector.m_bstrAttr = arg.Left(delimiterPos);
attrSelector.m_pos = CFilterElementHideAttrPos::EXACT;
}
}
CString tag = attrSelector.m_bstrAttr;
if (tag == "style")
{
attrSelector.m_type = CFilterElementHideAttrType::STYLE;
attrSelector.m_value.MakeLower();
}
else if (tag == "id")
{
attrSelector.m_type = CFilterElementHideAttrType::ID;
}
else if (tag == "class")
{
attrSelector.m_type = CFilterElementHideAttrType::CLASS;
}
m_attributeSelectors.push_back(attrSelector);
}
// End check
if (!filterString.IsEmpty())
{
DEBUG_FILTER("Filter::Error parsing selector:" + filterFile + "/" + filterText + " (more data)")
throw new std::runtime_error(CStringA("Filter::Error parsing selector:" + filterText + " (more data)").GetString());
}
}
bool CPluginFilter::AddFilterElementHide(CString filterText)
{
DEBUG_FILTER("Input: " + filterText + " filterFile" + filterFile);
CriticalSection::Lock filterEngineLock(s_criticalSectionFilterMap);
{
CString filterString = filterText;
// Create filter descriptor
std::auto_ptr<CFilterElementHide> filter;
CString wholeFilterString = filterString;
wchar_t separatorChar;
do
{
int chunkEnd = filterText.FindOneOf(L"+>");
if (chunkEnd > 0)
{
separatorChar = filterText.GetAt(chunkEnd);
}
else
{
chunkEnd = filterText.GetLength();
separatorChar = L'\0';
}
CString filterChunk = filterText.Left(chunkEnd).TrimRight();
std::auto_ptr<CFilterElementHide> filterParent(filter);
filter.reset(new CFilterElementHide(filterChunk));
if (filterParent.get() != 0)
{
filter->m_predecessor.reset(filterParent.release());
}
if (separatorChar != L'\0') // complex selector
{
filterText = filterText.Mid(chunkEnd + 1).TrimLeft();
if (separatorChar == '+')
filter->m_type = CFilterElementHide::TRAVERSER_TYPE_IMMEDIATE;
else if (separatorChar == '>')
filter->m_type = CFilterElementHide::TRAVERSER_TYPE_PARENT;
}
else // Terminating element (simple selector)
{
if (!filter->m_tagId.IsEmpty())
{
m_elementHideTagsId.insert(std::make_pair(std::make_pair(filter->m_tag, filter->m_tagId), *filter));
}
else if (!filter->m_tagClassName.IsEmpty())
{
m_elementHideTagsClass.insert(std::make_pair(std::make_pair(filter->m_tag, filter->m_tagClassName), *filter));
}
else
{
std::pair<CString, CFilterElementHide> pair = std::make_pair(filter->m_tag, *filter);
m_elementHideTags.insert(pair);
}
}
} while (separatorChar != '\0');
}
return true;
}
