FTMEXT_METHOD_OBJECT(rastafilt, NULL, obj)
{
rastafilt_t *self = (rastafilt_t *)FTMEXT_GET_EXT();
fts_object_t *obj = FTMEXT_GET_OBJECT();
int type;
float * data;
int size;
int stride;
if(obj != NULL) {
if(self->nfilt != -1) {
type=fmat_or_fvec_vector_lock((fts_object_t *)obj,&data,&size,&stride);
if((type==0)||(type==1)) {
ftmext_error((ftmext_t *)self,"UNSUPPORTED TYPE %d",type);
}
else if(type==2) {
//ftmext_post((ftmext_t *)self,"FMAT TYPE - size %d - stride %d - 1st-data %f",size,stride,data[0]);
if(((fmat_get_m((fmat_t *)obj))==1)||((fmat_get_n((fmat_t *)obj))==1)) {
//ftmext_post((ftmext_t *)self,"GOOD FMAT #row %d #col %d",fmat_get_m((fmat_t *)obj),fmat_get_n((fmat_t *)obj));
if(size==(self->nfilt)) {
memset(self->output,0,(self->nfilt)*sizeof(float));
rasta_filt(self,data);
memcpy(data,self->output,(self->nfilt)*sizeof(float));
fmat_or_fvec_unlock((fts_object_t *)obj);
if(self->obj != NULL) fts_object_release(self->obj);
self->obj = obj;
fts_object_refer(obj);
ftmext_outlet_object((ftmext_t *)self, 0, self->obj);
}
else {
ftmext_error((ftmext_t *)self,"INPUT SIZE %d IS DIFFERENT THAN NFILT=%d",size,(self->nfilt));
}
}
else {
ftmext_error((ftmext_t *)self,"ONLY FMAT WITH 1 COL OR 1 ROW SUPPORTED");
}
}
else {
ftmext_error((ftmext_t *)self,"UNKNOWN TYPE %d",type);
}
}
else {
ftmext_error((ftmext_t *)self,"NFILT WAS NOT SET");
}
}
FTMEXT_METHOD_RETURN;
}
FTMEXT_METHOD_NUMBER(rastafilt, num)
{
rastafilt_t *self = (rastafilt_t *)FTMEXT_GET_EXT();
int nfilt = FTMEXT_GET_INT();
int i;
if(nfilt <= 1) {
ftmext_error((ftmext_t *)self,"NFILT %d MUST BE BIGGER THAN 1",nfilt);
}
else {
/*clean using old filt number*/
if(self->nfilt != -1) {
for(i=0; i<self->nfilt; i++) {
free(self->filtIN[i]);
free(self->filtOUT[i]);
}
free(self->filtIN);
free(self->filtOUT);
free(self->output);
}
self->nfilt = nfilt;
self->filtIN=(float **)malloc(self->nfilt*sizeof(float *));
self->filtOUT=(float **)malloc(self->nfilt*sizeof(float *));
for(i=0; i<self->nfilt; i++) {
self->filtIN[i]=(float *)malloc(5*sizeof(float));
memset(self->filtIN[i],0,5*sizeof(float));
self->filtOUT[i]=(float *)malloc(5*sizeof(float));
memset(self->filtOUT[i],0,5*sizeof(float));
}
self->output=(float *)malloc(self->nfilt*sizeof(float));
self->eos = 1;
rasta_filt(self,(float *)NULL);
self->eos = 0;
}
FTMEXT_METHOD_RETURN;
}
FTMEXT_METHOD_VOID(rastafilt, reset)
{
rastafilt_t *self = (rastafilt_t *)FTMEXT_GET_EXT();
int i;
/*clean using old filt number*/
if(self->nfilt != -1) {
for(i=0; i<self->nfilt; i++) {
free(self->filtIN[i]);
free(self->filtOUT[i]);
}
free(self->filtIN);
free(self->filtOUT);
free(self->output);
self->filtIN=(float **)malloc(self->nfilt*sizeof(float *));
self->filtOUT=(float **)malloc(self->nfilt*sizeof(float *));
for(i=0; i<self->nfilt; i++) {
self->filtIN[i]=(float *)malloc(5*sizeof(float));
memset(self->filtIN[i],0,5*sizeof(float));
self->filtOUT[i]=(float *)malloc(5*sizeof(float));
memset(self->filtOUT[i],0,5*sizeof(float));
}
self->output=(float *)malloc(self->nfilt*sizeof(float));
self->eos = 1;
rasta_filt(self,(float *)NULL);
self->eos = 0;
}
FTMEXT_METHOD_RETURN;
}
/*
This is the main routine for the analysis on a frame;
it assumes only that the windowed speech has been put into
an fvec pointed to by fptr, and that the analysis parameters
are all available in the structure pointed to by pptr .
It returns a pointer to the cepstral fvec for this frame.
The called routines initialize required tables if
called for the first time.
*/
struct fvec *rastaplp(struct fhistory *hptr, struct param *pptr, struct fvec *fptr)
{
struct fvec *pspectrum, *aspectrum, *nl_aspectrum,
*ras_aspectrum, *ras_nl_aspectrum,
*ras_postaspectrum, *cepstrum;
struct fvec *npower;
struct fmat *map_source;
static struct map_param mapping_param;
int mapset;
char *funcname;
funcname = "rastaplp";
/* Compute the power spectrum from the windowed input */
pspectrum = powspec(pptr, fptr);
/* Compute critical band (auditory) spectrum */
aspectrum = audspec(pptr, pspectrum);
/*---Jah Rasta with spectral mapping -----------------*/
if ((pptr->jrasta == TRUE ) && (pptr->cJah == FALSE))
{
npower = comp_noisepower(hptr, pptr, aspectrum);
if (npower->values[0] < TINY)
pptr->jah = 1.0e-6;
else
pptr->jah = 1/(C_CONSTANT * npower->values[0]);
comp_Jah(pptr, &mapping_param, &mapset);
}
/* Put into some nonlinear domain */
nl_aspectrum = nl_audspec(pptr, aspectrum);
/* Do rasta filtering */
ras_nl_aspectrum = rasta_filt(hptr, pptr, nl_aspectrum);
if ((pptr->crbout) == FALSE)
{
if ((pptr->jrasta == TRUE) && (pptr->cJah == FALSE))
{
map_source = cr_map_source_data(pptr, &mapping_param, ras_nl_aspectrum);
do_mapping(pptr,&mapping_param, map_source, mapset, ras_nl_aspectrum);
}
/* Take the quasi inverse on the nonlinearity
(currently just an exp) */
ras_aspectrum = inverse_nonlin(pptr, ras_nl_aspectrum);
/* Do final cube-root compression and equalization */
ras_postaspectrum = post_audspec(pptr, ras_aspectrum);
if ((pptr->comcrbout) == FALSE)
{
/* Code to do final smoothing; initial implementation
will only permit plp-style lpc-based representation,
which will consist of inverse dft followed
by autocorrelation-based lpc analysis and an
lpc to cepstrum recursion. */
cepstrum = lpccep(pptr, ras_postaspectrum);
return( cepstrum );
}
else
{
return( ras_postaspectrum );
}
}
else
{
return(ras_nl_aspectrum); /* return the critical band energies
after bandpass filtering */
}
}
