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;
}
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 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::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 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;
}
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 AdvancedFrameTokenizer::init(const YAAFE::ParameterMap& params, const YAAFE::Ports<YAAFE::StreamInfo>& inp)
{
assert(inp.size()==1);
const StreamInfo& in = inp[0].data;
if (in.size > 1)
{
cerr << "ERROR: input of AdvancedFrameTokenizer should be of size 1" << endl;
return false;
}
m_outSampleRate = getDoubleParam("outSampleRate",params);
m_blockSize = getIntParam("blockSize",params);
m_outStepSize = getIntParam("outStepSize",params);
StreamInfo out;
out.frameLength = (int) floor(in.frameLength*m_blockSize*m_outSampleRate/in.sampleRate + 0.5);
out.sampleRate = m_outSampleRate;
out.sampleStep = m_outStepSize;
out.size = m_blockSize;
outStreamInfo().add(out);
return true;
}
bool AudioFileReader::init(const ParameterMap& params, const Ports<StreamInfo>& in)
{
m_resample = (getStringParam("Resample", params)=="yes");
m_removemean = (getStringParam("RemoveMean",params)=="yes");
m_scaleMax = getDoubleParam("ScaleMax",params);
m_sampleRate = getIntParam("SampleRate",params);
string filename = getStringParam("File", params);
string timeStart = getStringParam("TimeStart",params);
if (timeStart[timeStart.size()-1]=='s')
{
m_startSecond = atof(timeStart.substr(0,timeStart.size()-1).c_str());
} else {
cerr << "ERROR: invalid TimeStart parameter !" << endl;
return false;
}
string timeLimit = getStringParam("TimeLimit",params);
if (timeLimit[timeLimit.size()-1]=='s')
{
m_limitSecond = atof(timeLimit.substr(0,timeLimit.size()-1).c_str());
} else {
cerr << "ERROR: invalid TimeLimit parameter !" << endl;
return false;
}
m_bufferSize = DataBlock::preferedBlockSize();
m_readBuffer = new double[2*m_bufferSize]; // enough to read stereo if needed
if (!openFile(filename))
return false;
// find mean and max if needed
m_mean = 0;
m_factor = 1;
if (m_removemean || m_scaleMax>0)
{
m_rescale = true;
int count = 0;
double smean = 0;
double smin = 0;
double smax = 0;
while (true) {
int nbRead = readFramesIntoBuffer();
if (nbRead==0)
break;
for (int i=0;i<nbRead;i++)
{
smean += m_readBuffer[i];
if (m_readBuffer[i]<smin)
smin = m_readBuffer[i];
if (m_readBuffer[i]>smax)
smax = m_readBuffer[i];
}
count += nbRead;
}
if (m_removemean)
m_mean = smean / count;
if (m_scaleMax>0)
m_factor = m_scaleMax / max(abs( (smax-m_mean) ),abs( (smin-m_mean) ));
int res = sf_seek(m_sndfile,0,SEEK_SET);
if (res!=0)
{
cerr << "ERROR: cannot seek start in audio file !" << endl;
return false;
}
if (verboseFlag)
cerr << "INFO: remove mean of input signal (" << m_mean << ") and scale to " << m_scaleMax << endl;
closeFile();
if (!openFile(filename)) {
cerr << "ERROR: cannot re-open file " << filename << " !" << endl;
return false;
}
}
if ((!m_resample) && (m_sfinfo.samplerate != m_sampleRate)) {
cerr << "ERROR: resampling is disabled and file has sample rate " << m_sfinfo.samplerate << " Hz. Expecting " << m_sampleRate << " Hz !" << endl;
return false;
}
outStreamInfo().add(StreamInfo());
StreamInfo& outInfo = outStreamInfo()[0].data;
outInfo.size = 1;
outInfo.sampleRate = m_sampleRate;
outInfo.sampleStep = 1;
outInfo.frameLength = 1;
return true;
}
