bool Flux::process(Ports<InputBuffer*>& inp, Ports<OutputBuffer*>& outp)
{
assert(inp.size()==1);
InputBuffer* in = inp[0].data;
assert(outp.size()==1);
OutputBuffer* out = outp[0].data;
if ((out->tokenno()==0) && (in->tokenno()!=-1))
in->prependZeros(1);
if (!in->hasTokens(2))
return false;
const int N = in->info().size;
double lastNorm = 0.0;
double nextNorm = Map<VectorXd>(in->token(0),N).norm();
while (in->hasTokens(2))
{
Map<VectorXd> last(in->token(0),N);
lastNorm = nextNorm;
Map<VectorXd> next(in->token(1),N);
nextNorm = next.norm();
double* output = out->writeToken();
if (lastNorm*nextNorm==0)
*output = 0.0;
else if (m_onlyIncrease)
*output = (next-last).unaryExpr(filterNegativeOp<double>()).squaredNorm() / (lastNorm*nextNorm);
else
*output = (next - last).squaredNorm() / (lastNorm * nextNorm);
in->consumeToken();
}
return true;
}
bool Variation::process(Ports<InputBuffer*>& inp, Ports<OutputBuffer*>& outp)
{
assert(inp.size()==1);
InputBuffer* in = inp[0].data;
if (!in->hasTokens(2)) return false;
assert(outp.size()==1);
OutputBuffer* out = outp[0].data;
if ((out->tokenno()==0) && (in->tokenno()!=-1))
in->prependZeros(1);
const int N = in->info().size;
double lastNorm = 0.0;
double nextNorm = Map<VectorXd>(in->token(0),N).norm();
while (in->hasTokens(2))
{
Map<VectorXd> last(in->token(0),N);
lastNorm = nextNorm;
Map<VectorXd> next(in->token(1),N);
nextNorm = next.norm();
if (lastNorm*nextNorm !=0)
lastNorm = 1 - last.dot(next) / (lastNorm * nextNorm);
else
lastNorm = 0.0;
out->write(&lastNorm,1);
in->consumeToken();
}
return true;
}
bool ComplexDomainFlux::process(Ports<InputBuffer*>& inp, Ports<OutputBuffer*>& outp)
{
assert(inp.size()==1);
InputBuffer* in = inp[0].data;
assert(outp.size()==1);
OutputBuffer* out = outp[0].data;
if ((out->tokenno()==0) && (in->tokenno()!=-2))
in->prependZeros(2);
if (!in->hasTokens(3)) return false;
const int N = in->info().size/2;
ArrayXcd inPredPredRotator(N);
ArrayXcd inPredRotator(N);
rotatorOp<double> op;
{
Map<ArrayXcd> inPredPredData((complex<double>*) in->token(0),N);
inPredPredRotator = inPredPredData.unaryExpr(op);
}
while (in->hasTokens(3))
{
Map<ArrayXcd> inPredData((complex<double>*) in->token(1),N);
Map<ArrayXcd> inData((complex<double>*) in->token(2), N);
inPredRotator = inPredData.unaryExpr(op);
double* output = out->writeToken();
*output++ = (inData - (inPredData * (inPredRotator * inPredPredRotator.conjugate()))).abs().sum();
in->consumeToken();
inPredPredRotator.swap(inPredRotator);
}
return true;
}
bool DataPool::removeComponent(TaskContext* comp) {
Logger::In in(getName());
Ports ports = comp->ports()->getPorts();
for (Ports::iterator it = ports.begin(); it != ports.end() ; ++it) {
this->removePort(*it);
}
return true;
}
bool SpectralCrestFactorPerBand::process(Ports<InputBuffer*>& inp, Ports<OutputBuffer*>& outp)
{
assert(inp.size()==1);
InputBuffer* in = inp[0].data;
if (in->empty()) return false;
assert(outp.size()==1);
OutputBuffer* out = outp[0].data;
int nbBands = m_band.size();
double* tmp = new double[in->info().size];
while (!in->empty())
{
double* inData = in->readToken();
double* output = out->writeToken();
for (int k=0;k<nbBands;++k)
{
bandinfo& bi = m_band[k];
double* data = &inData[bi.start];
int datalen = bi.length();
if (bi.group>1) // grpsize > 1
{
data = tmp;
datalen /= bi.group;
double* ptr = &inData[bi.start];
for (int d=0;d<datalen;d++) {
double s = 0;
for (int g=0;g<bi.group;g++)
s += *ptr++;
data[d] = s;
}
}
double am = 0;
double maxdata = data[0];
for (int i=0;i<datalen;i++)
{
am += data[i];
if (data[i]>maxdata) {
maxdata = data[i];
}
}
if (am!=0) {
output[k] = maxdata * datalen / am;
continue;
}
output[k] = maxdata / EPS;
}
in->consumeToken();
}
delete [] tmp;
return true;
}
bool Logger::unreportComponent( const std::string& component ) {
TaskContext* comp = this->getPeer(component);
if (!comp)
{
log(Error) << "no such component " << component << endlog();
return false;
}
Ports ports = comp->ports()->getPorts();
for (Ports::iterator it = ports.begin(); it != ports.end() ; ++it) {
this->unreportPort(component, (*it)->getName());
}
return true;
}
bool AudioFileReader::process(Ports<InputBuffer*>& inp, Ports<OutputBuffer*>& outp)
{
assert(inp.size()==0);
assert(outp.size()==1);
OutputBuffer* out = outp[0].data;
int nbRead = readFramesIntoBuffer();
if (nbRead==0)
return false;
if (m_rescale)
for (int i=0;i<nbRead;i++)
m_readBuffer[i] = (m_readBuffer[i] - m_mean) * m_factor;
out->write(m_readBuffer,nbRead);
return true;
}
bool Logger::reportComponent( const std::string& component ) {
// Users may add own data sources, so avoid duplicates
//std::vector<std::string> sources = comp->data()->getNames();
TaskContext* comp = this->getPeer(component);
if ( !comp )
{
log(Error) << "no such component " << component << endlog();
return false;
}
Ports ports = comp->ports()->getPorts();
for (Ports::iterator it = ports.begin(); it != ports.end() ; ++it)
this->reportPort( component, (*it)->getName() );
return true;
}
bool FrameTokenizer::init(const ParameterMap& params, const Ports<StreamInfo>& inp)
{
assert(inp.size()==1);
const StreamInfo& in = inp[0].data;
if (in.size > 1)
{
cerr << "ERROR: input of FrameTokenizer should be of size 1" << endl;
return false;
}
m_blockSize = getIntParam("blockSize", params);
if (m_blockSize<=0) {
cerr << "ERROR: invalid blockSize parameter !" << endl;
}
m_stepSize = getIntParam("stepSize", params);
if (m_stepSize<=0) {
cerr << "ERROR: invalid stepSize parameter !" << endl;
return false;
}
outStreamInfo().add(StreamInfo());
StreamInfo& outInfo = outStreamInfo()[0].data;
outInfo.sampleRate = in.sampleRate;
outInfo.frameLength = m_blockSize * in.frameLength;
outInfo.sampleStep = m_stepSize * in.sampleStep;
outInfo.size = m_blockSize;
return true;
}
void FrameTokenizer::flush(Ports<InputBuffer*>& inp, Ports<OutputBuffer*>& outp)
{
assert(inp.size()==1);
InputBuffer* in = inp[0].data;
in->appendZeros((m_blockSize-1)/2);
process(inp,outp);
}
bool Variation::init(const ParameterMap& params, const Ports<StreamInfo>& inp)
{
assert(inp.size()==1);
const StreamInfo& in = inp[0].data;
outStreamInfo().add(StreamInfo(in,1));
return true;
}
bool AC2LPC::process(Ports<InputBuffer*>& inp, Ports<OutputBuffer*>& outp)
{
assert(inp.size()==1);
InputBuffer* in = inp[0].data;
assert(outp.size()==1);
OutputBuffer* out = outp[0].data;
assert(out->info().size==m_nbCoeffs);
assert(in->info().size>m_nbCoeffs);
while (!in->empty())
{
ac2lpc(in->readToken(),out->writeToken(),m_nbCoeffs);
in->consumeToken();
}
return true;
}
bool DataPool::addComponent(TaskContext* comp) {
Logger::In in(getName());
log(Debug) << "Adding component " << comp->getName() << "." << endlog();
Ports ports = comp->ports()->getPorts();
for (Ports::iterator it = ports.begin(); it != ports.end() ; ++it) {
RTT::base::PortInterface *port = *it;
if (port->connected()) {
log(Debug) << "Ignoring port " << comp->getName() << "/" << port->getName() << ": already connected" << endlog();
continue;
}
this->addPort(port);
}
return true;
}
bool CSVWriter::init(const ParameterMap& params, const Ports<StreamInfo>& inp)
{
assert(inp.size()==1);
const StreamInfo& in = inp[0].data;
string outputFile = getStringParam("File", params);
m_precision = getIntParam("Precision",params);
if (m_precision > (BUFSIZE-10)) {
cerr << "WARNING: precision is too large ! use precision " << BUFSIZE - 10 << endl;
m_precision = BUFSIZE - 10;
}
int res = preparedirs(outputFile.c_str());
if (res!=0)
return false;
m_fout.open(outputFile.c_str(), ios_base::trunc);
if (!m_fout.is_open() || m_fout.bad())
return false;
if (getStringParam("Metadata",params)=="True") {
// write metadata at the beginnig of the file
string paramStr = getStringParam("Attrs",params);
map<string,string> params = decodeAttributeStr(paramStr);
ostringstream oss;
for (map<string,string>::const_iterator it=params.begin();it!=params.end();it++)
oss << "% " << it->first << "=" << it->second << endl;
m_fout.write(oss.str().c_str(),oss.str().size());
}
return true;
}
bool MelFilterBank::init(const ParameterMap& params, const Ports<StreamInfo>& inp)
{
assert(inp.size()==1);
const StreamInfo& in = inp[0].data;
// build mel filter bank
m_size = in.size;
int nbMelFilters = getIntParam("MelNbFilters",params);
double sampleRate = in.sampleRate;
double freqMin = getDoubleParam("MelMinFreq",params);
double freqMax = getDoubleParam("MelMaxFreq",params);
// set freqMax to Nyquist frequency if greater than nyquist frequency
freqMax = min(freqMax, sampleRate/2.0);
double melFreqMin = 1127 * log(1 + freqMin / 700);
double melFreqMax = 1127 * log(1 + freqMax / 700);
VectorXd melPeak(nbMelFilters+2);
VectorXd freqs(nbMelFilters+2);
melPeak = VectorXd::LinSpaced(nbMelFilters+2,melFreqMin,melFreqMax);
freqs = ((melPeak / 1127).array().exp() - 1.0) * 700.0;
VectorXd fftFreqs(m_size);
fftFreqs = VectorXd::LinSpaced(m_size,0,m_size-1) * sampleRate / ((m_size-1)*2);
for (int b=1;b<nbMelFilters+1;b++)
{
double norm = 2.0 / (freqs(b+1)-freqs(b-1));
VectorXd fullfilt(m_size);
// fullfilt.setZero(m_size);
// firstIndex i;
// fullfilt += where((fftFreqs(i)>freqs(b-1)) && (fftFreqs(i)<=freqs(b)),norm*(fftFreqs(i)-freqs(b-1))/(freqs(b)-freqs(b-1)),0.0);
// fullfilt += where((fftFreqs(i)>freqs(b)) && (fftFreqs(i)<freqs(b+1)),norm*(freqs(b+1)-fftFreqs(i))/(freqs(b+1)-freqs(b)),0.0);
double ffmin = freqs(b-1);
double ffmiddle = freqs(b);
double ffmax = freqs(b+1);
for (int i=0;i<m_size;i++) {
if ((fftFreqs(i)<ffmin) || (fftFreqs(i)>ffmax)) {
fullfilt(i) = 0;
continue;
}
if (fftFreqs(i)<ffmiddle)
fullfilt(i) = norm*(fftFreqs(i)-ffmin)/(ffmiddle-ffmin);
else
fullfilt(i) = norm*(ffmax-fftFreqs(i))/(ffmax-ffmiddle);
}
int fStart=0;
while (fullfilt(fStart)==0.0) fStart++;
int fEnd=fStart+1;
while ((fEnd<m_size) && (fullfilt(fEnd)!=0.0)) fEnd++;
m_filterStart.push_back(fStart);
m_filters.push_back(RowVectorXd());
m_filters.back() = fullfilt.segment(fStart,fEnd-fStart);
}
outStreamInfo().add(StreamInfo(in, m_filters.size()));
return true;
}
bool AC2LPC::init(const ParameterMap& params, const Ports<StreamInfo>& inp)
{
assert(inp.size()==1);
const StreamInfo& in = inp[0].data;
m_nbCoeffs = getIntParam("LPCNbCoeffs",params);
outStreamInfo().add(StreamInfo(in,m_nbCoeffs));
return true;
}
bool Flux::init(const ParameterMap& params, const Ports<StreamInfo>& inp)
{
assert(inp.size()==1);
const StreamInfo& in = inp[0].data;
m_onlyIncrease = (getStringParam("FluxSupport",params)=="Increase");
outStreamInfo().add(StreamInfo(in,1));
return true;
}
bool Difference::process(Ports<InputBuffer*>& inp, Ports<OutputBuffer*>& outp)
{
assert(inp.size()==1);
InputBuffer* in = inp[0].data;
if (in->empty()) return false;
assert(outp.size()==1);
OutputBuffer* out = outp[0].data;
const int N = in->info().size - 1;
while (!in->empty())
{
double* inData = in->readToken();
double* outData = out->writeToken();
for (int i=0;i<N;i++)
outData[i] = inData[i+1] - inData[i];
in->consumeToken();
}
return true;
}
bool Cepstrum::process(Ports<InputBuffer*>& inp, Ports<OutputBuffer*>& outp)
{
assert(inp.size()==1);
InputBuffer* in = inp[0].data;
if (in->empty())
return false;
assert(outp.size()==1);
OutputBuffer* out = outp[0].data;
safeLogOp<double> slop;
VectorXd outDct;
while (!in->empty())
{
Map<VectorXd> inData(in->readToken(),in->info().size);
outDct.noalias() = m_dctPlan * inData.unaryExpr(slop);
memcpy(out->writeToken(),outDct.data() + m_ignoreFirst, out->info().size*sizeof(double));
in->consumeToken();
}
return true;
}
bool CSVWriter::process(Ports<InputBuffer*>& inp, Ports<OutputBuffer*>& outp)
{
assert(inp.size()==1);
InputBuffer* in = inp[0].data;
assert(outp.size()==0);
char buf[BUFSIZE];
while (!in->empty())
{
double* data = in->readToken();
int strSize = sprintf(buf,"%0.*e",m_precision,data[0]);
m_fout.write(buf,strSize);
for (int i=1;i<in->info().size;i++)
{
strSize = sprintf(buf,",%0.*e",m_precision,data[i]);
m_fout.write(buf,strSize);
}
m_fout << endl;
in->consumeToken();
}
return true;
}
bool MelFilterBank::process(Ports<InputBuffer*>& inp, Ports<OutputBuffer*>& outp)
{
assert(inp.size()==1);
InputBuffer* in = inp[0].data;
if (in->empty()) return false;
assert(outp.size()==1);
OutputBuffer* out = outp[0].data;
while (!in->empty()) {
Map<VectorXd> inData(in->readToken(),in->info().size);
double* outData = out->writeToken();
for (int f=0;f<m_filters.size();f++)
{
RowVectorXd& filter = m_filters[f];
outData[f] = filter * inData.segment(m_filterStart[f],filter.size());
}
in->consumeToken();
}
return true;
}
bool FrameTokenizer::process(Ports<InputBuffer*>& inp, Ports<OutputBuffer*>& outp)
{
assert(inp.size()==1);
InputBuffer* in = inp[0].data;
assert(outp.size()==1);
OutputBuffer* out = outp[0].data;
assert(in->size()==1);
if ((out->tokenno()==0) && (in->tokenno()!=-m_blockSize/2))
in->prependZeros(m_blockSize/2);
if (!in->hasTokens(m_blockSize))
return false;
while (in->hasTokens(m_blockSize)) {
in->read(out->writeToken(),m_blockSize);
in->consumeTokens(m_stepSize);
}
return true;
}
bool SpecificLoudness::process(Ports<InputBuffer*>& inp, Ports<OutputBuffer*>& outp)
{
assert(inp.size()==1);
InputBuffer* in = inp[0].data;
if (in->empty()) return false;
assert(outp.size()==1);
OutputBuffer* out = outp[0].data;
const int N = in->info().size;
const int M = out->info().size;
while (!in->empty())
{
Map<VectorXd> inData(in->readToken(),N);
double* outData = out->writeToken();
for (int i=0;i<NB_BARK_BANDS;i++)
outData[i] = pow(inData.segment(m_bkBdLimits[i],m_bkBdLimits[i+1]-m_bkBdLimits[i]).sum(),0.23);
in->consumeToken();
}
return true;
}
void
run()
{
TestSink sink {*this};
sink.severity (beast::Journal::Severity::kAll);
beast::Journal journal {sink};
TestHandler handler;
Server s (handler, journal);
Ports ports;
std::unique_ptr <RippleSSLContext> c (
RippleSSLContext::createBare ());
ports.emplace_back (testPort, beast::IP::Endpoint (
beast::IP::AddressV4 (127, 0, 0, 1), 0),
Port::Security::no_ssl, c.get());
s.setPorts (ports);
test_request();
//test_keepalive();
s.stop();
pass();
}
int main()
{
memset(message_buff, 0, sizeof(reply_buf));
//Initialize structures
Object o;
UndoHistory hist;
Rt rt(&o, &hist);
hist.setCallback([&rt](const char*msg) {ports.dispatch(msg+1, rt);});
assert_int_eq(0, o.b, "Verify Zero Based Initialization", __LINE__);
rt.matches = 0;
int len = rtosc_message(message_buff, 128, "b", "c", 7);
assert_hex_eq(ref, message_buff, sizeof(ref)-1, len,
"Build Param Change Message", __LINE__);
ports.dispatch(message_buff, rt);
assert_int_eq(1, rt.matches,
"Verify A Single Leaf Dispatch Has Occured", __LINE__);
assert_int_eq(7, o.b, "Verify State Change Has Been Applied", __LINE__);
rt.enable = false;
printf("#Current History:\n");
hist.showHistory();
hist.seekHistory(-1);
assert_int_eq(0, o.b,
"Verify Undo Has Returned To Zero-Init State", __LINE__);
printf("#Current History:\n");
hist.showHistory();
hist.seekHistory(+1);
assert_int_eq(7, o.b,
"Verify Redo Has Returned To Altered State", __LINE__);
return test_summary();
}
int main()
{
char buffer[1024];
memset(buffer, 0, sizeof(buffer));
walk_ports(&ports,
buffer, 1024, NULL,
[](const Port*, const char *name, void *) {
puts(name);
});
const Port *p = ports.apropos("/subtree/port");
if(p && (std::string(p->name) == "port"))
return 0;
return 1;
}
bool Difference::init(const ParameterMap& params, const Ports<StreamInfo>& inp)
{
assert(inp.size()==1);
const StreamInfo& in = inp[0].data;
m_nbCoeffs = getIntParam("DiffNbCoeffs",params);
if (m_nbCoeffs==0)
m_nbCoeffs = in.size - 1;
if (m_nbCoeffs > in.size-1)
{
cerr << "Warning: cannot compute " << m_nbCoeffs << " difference coefficients from input of size " << in.size << endl;
m_nbCoeffs = in.size - 1;
cerr << "take only " << m_nbCoeffs << " coefficients" << endl;
}
outStreamInfo().add(StreamInfo(in,m_nbCoeffs));
return true;
}
bool SpectralCrestFactorPerBand::init(const ParameterMap& params, const Ports<StreamInfo>& inp)
{
assert(inp.size()==1);
const StreamInfo& in = inp[0].data;
m_inSize = in.size;
double fs = in.sampleRate;
int blockSize = (in.size-1)*2; // assume input is spectrum
double hiedge = floor(fs/2);
double loedge = hiedge * pow(2,round(log2(250.0/hiedge)));
int k = 0;
while (true)
{
k++;
double f_lo_nom = loedge * pow(2,(double)(k-1)/4.0);
double f_hi_nom = loedge * pow(2,(double)k/4.0);
double f_lo = f_lo_nom * (1 - OVERLAP);
double f_hi = f_hi_nom * (1 + OVERLAP);
int i_lo = (int) round(f_lo / (fs/blockSize));
int i_hi = (int) round(f_hi / (fs/blockSize));
if (f_lo_nom >= hiedge) break;
if (f_hi > fs/2) break;
int grpsize = 1;
if (f_lo_nom >= 1000)
{
grpsize = (int) round(pow(2, floor(log2(f_lo_nom/500.0))));
i_hi = (int) round((double)(i_hi-i_lo+1)/grpsize)*grpsize + i_lo-1;
}
bandinfo bi;
bi.start = i_lo;
bi.end = i_hi+1;
bi.group = grpsize;
m_band.push_back(bi);
}
outStreamInfo().add(StreamInfo(in,m_band.size()));
return true;
}
bool SpecificLoudness::init(const ParameterMap& params, const Ports<StreamInfo>& inp)
{
assert(inp.size()==1);
const StreamInfo& in = inp[0].data;
// assume in->info().size is fft size
// assume in->info().frameLength is frame size
m_blockSize = in.frameLength;
m_fftSize = in.size;
m_bkBdLimits = new int[NB_BARK_BANDS+1];
double tmp[m_fftSize];
for (int i = 0; i < m_fftSize; i++)
{
tmp[i] = i * in.sampleRate / (double) m_blockSize;
tmp[i] = 13 * atan(tmp[i] / 1315.8) + 3.5 * atan(pow(
(tmp[i] / 7518), 2));
}
m_bkBdLimits[0] = 0;
double currentBandEnd = tmp[m_fftSize-1] / NB_BARK_BANDS;
int currentBarkBand = 1;
for (int i = 0; i < m_fftSize; i++)
{
while (tmp[i] > currentBandEnd)
{
m_bkBdLimits[currentBarkBand++] = i;
currentBandEnd = currentBarkBand * tmp[m_fftSize-1] / NB_BARK_BANDS;
}
}
assert(currentBarkBand == NB_BARK_BANDS);
m_bkBdLimits[NB_BARK_BANDS] = m_fftSize-1; // ignore last coeff
outStreamInfo().add(StreamInfo(in,NB_BARK_BANDS));
return true;
}
bool Cepstrum::init(const ParameterMap& params, const Ports<StreamInfo>& inp)
{
assert(inp.size()==1);
const StreamInfo& in = inp[0].data;
m_ignoreFirst = getIntParam("CepsIgnoreFirstCoeff",params);
m_nbCoeffs = getIntParam("CepsNbCoeffs",params);
if (m_nbCoeffs+m_ignoreFirst>in.size)
{
cerr << "Warning: cannot compute " << m_nbCoeffs << " for input of size " << in.size << endl;
m_nbCoeffs = in.size - m_ignoreFirst;
cerr << "compute only " << m_nbCoeffs << " coefficients" << endl;
}
m_dctPlan.resize(in.size,in.size);
for (int j=0;j<in.size;j++)
m_dctPlan(0,j) = 1.0 / sqrt((double)in.size);
for (int i=1;i<in.size;i++)
for (int j=0;j<in.size;j++)
m_dctPlan(i,j) = sqrt(2.0 / in.size) * cos(PI * (j + 0.5) * i / in.size);
outStreamInfo().add(StreamInfo(in, m_nbCoeffs));
return true;
}
