/*
* Manual page at fst_man.def
*/
INT16 CGEN_PUBLIC CFst_Intersect
(
CFst* _this,
CFst* itSrc1,
CFst* itSrc2,
INT32 nUnit1,
INT32 nUnit2
)
{
CFst* itAux1 = NULL;
CFst* itAux2 = NULL;
CData* idAux = NULL;
INT32 nIcTis1 = -1;
INT32 nIcTos1 = -1;
INT32 nIcTis2 = -1;
INT32 nIcTos2 = -1;
INT16 nErr = O_K;
nIcTis1 = CData_FindComp(AS(CData,itSrc1->td),NC_TD_TIS);
nIcTos1 = CData_FindComp(AS(CData,itSrc1->td),NC_TD_TOS);
nIcTis2 = CData_FindComp(AS(CData,itSrc2->td),NC_TD_TIS);
nIcTos2 = CData_FindComp(AS(CData,itSrc2->td),NC_TD_TOS);
if (nIcTis1<0) return IERROR(_this,FST_MISS,"input symbol component","","transition table of left operand");
if (nIcTis2<0) return IERROR(_this,FST_MISS,"input symbol component","","transition table of right operand");
ICREATEEX(CFst ,itAux1,"CFst_Intersect.itAux1",NULL);
ICREATEEX(CFst ,itAux2,"CFst_Intersect.itAux2",NULL);
ICREATEEX(CData,idAux ,"CFst_Intersect.idAux" ,NULL);
CFst_Copy(BASEINST(itAux1),BASEINST(itSrc1));
CFst_Copy(BASEINST(itAux2),BASEINST(itSrc2));
if (nIcTos1>=0)
{
CData_DeleteComps(AS(CData,itAux1->td),nIcTos1,1);
CData_SelectComps(idAux,AS(CData,itAux1->td),nIcTis1,1);
CData_SetCname(idAux,0,NC_TD_TOS);
CData_Join(AS(CData,itAux1->td),idAux);
}
if (nIcTos2>=0)
{
CData_DeleteComps(AS(CData,itAux2->td),nIcTos2,1);
CData_SelectComps(idAux,AS(CData,itAux2->td),nIcTis2,1);
CData_SetCname(idAux,0,NC_TD_TOS);
CData_Join(AS(CData,itAux2->td),idAux);
}
nErr = CFst_Compose(_this,itAux1,itAux2,nUnit1,nUnit2);
IDESTROY(itAux1);
IDESTROY(itAux2);
IDESTROY(idAux);
return nErr;
}
/*
* Synthesis using pitch marks.
*
* Derived instances of FBAproc should override method
* SynthesizePM() to add the desired functionality
*
* @return O_K if successfull, NOT_EXEC otherwise
*/
INT16 CGEN_VPROTECTED CFBAproc::SynthesizeUsingPM(data *idFea, data *idPm, data *idSyn) {
CData *idExcite = NULL;
FLOAT64 *excitation = NULL;
FLOAT64 *synthesis = NULL;
INT32 nSamples = 0;
INT16 nPer = 0;
INT32 nCompVuv = idFea->FindComp("v/uv");
INT16 nCompFea = idFea->GetNNumericComps() - (nCompVuv >= 0 ? 1 : 0);
INT32 iRecFea = 0;
INT32 nRecFea = 0;
AlignFramesToPitch(idPm, idFea, idFea);
nRecFea = idFea->GetNRecs();
if(m_bSynEnhancement) {
for(iRecFea = 0; iRecFea < nRecFea; iRecFea++) {
FeaEnhancement((FLOAT64*)idFea->XAddr(iRecFea,0), nCompFea);
}
}
Smooth(idFea, idPm, idFea);
// Generate modulated excitation
ICREATEEX(CData,idExcite,"~idExcite",NULL);
DLPASSERT(O_K==ModEx(idPm,idExcite));
DLPASSERT(!idExcite->IsEmpty());
nSamples = idExcite->GetNRecs();
idSyn->Reset();
idSyn->AddComp("syn", T_DOUBLE);
idSyn->Allocate(nSamples);
excitation = (FLOAT64*)idExcite->XAddr(0, 0);
synthesis = (FLOAT64*)idSyn->XAddr(0, 0);
for(INT32 currSample = 0, currPer = 0; (currSample < nSamples) && (currPer < idFea->GetNRecs()); currSample += nPer, currPer++) {
nPer = (INT16)idPm->Dfetch(currPer,0);
if(SynthesizeFrame((FLOAT64*)idFea->XAddr(currPer,0), nCompFea, excitation+currSample, nPer, synthesis+currSample) != O_K) {
IDESTROY(idExcite);
return IERROR(this,FBA_SYNTHESISE, currPer, 0,0);
}
}
IDESTROY(idExcite);
if (m_nMinLog != 0.0) for (INT32 i=0; i<idSyn->GetNRecs(); i++) *((FLOAT64*)idSyn->XAddr(0, 0)+i) *= exp(m_nMinLog);
return O_K;
}
INT16 CGEN_PROTECTED CPMproc::Analyze(data* dSignal, data* dPM) {
INT16 ret = NOT_EXEC;
INT16 bLabels = FALSE;
data* dLabels = NULL;
ICREATEEX(CData,dLabels,"~lab",NULL);
if(dlp_is_symbolic_type_code(dSignal->GetCompType(dSignal->GetNComps()-1))) {
dLabels->SelectComps(dSignal,dSignal->GetNComps()-1,1);
dSignal->DeleteComps(dSignal->GetNComps()-1,1);
bLabels=TRUE;
}
if(m_bChfa == true) {
ret = Chfa(dSignal, dPM);
} else if(m_bGcida == true) {
ret = Gcida(dSignal, dPM);
} else if(m_bEpochdetect == true) {
ret = Epochdetect(dSignal, dPM);
} else {
ret = Hybrid(dSignal, dPM);
}
if(bLabels==TRUE) {
dSignal->Join(dLabels);
}
IDESTROY(dLabels);
return ret;
}
/* Make up a new definition, recalc and scroll to make it visible.
*/
Symbol *
workspace_add_def_recalc( Workspace *ws, const char *str )
{
Column *col = workspace_column_pick( ws );
Symbol *sym;
#ifdef DEBUG
printf( "workspace_add_def_recalc: %s\n", str );
#endif /*DEBUG*/
if( !(sym = workspace_add_def( ws, str )) )
return( NULL );
if( !symbol_recalculate_check( sym ) ) {
/* Eval error.
*/
expr_error_get( sym->expr );
error_block();
IDESTROY( sym );
error_unblock();
return( NULL );
}
/* Jump to column containing object.
*/
column_scrollto( col, MODEL_SCROLL_BOTTOM );
return( sym );
}
/**
* Writes the data transfer file of this process. This method is called
* immediately before starting the operating system process.
*/
INT16 CGEN_PUBLIC CProcess::SendData()
{
DLP_FILE* pfScr; // Slave script file pointer
INT32 i; // Loop counter
char sScrFn[L_PATH]; // Slave script file name
char sDtoFn[L_PATH]; // Data transfer file name
if (m_nState & PRC_DATASENT) return NOT_EXEC; // Data have already been sent
if (m_iDto) // This process is a function call
{ // >>
sprintf(sScrFn,"%s.xtp",m_psTmpFile); // Get slave script file name
sprintf(sDtoFn,"%s.xml",m_psTmpFile); // Get data transfer fine name
pfScr = dlp_fopen(sScrFn,"w"); // Open temporary script file
for (i=0; dlp_strcmp(__sSlaveScript[i],"\0")!=0; i++) // Loop over slave script lines
{ // >>
dlp_fwrite(__sSlaveScript[i],1,dlp_strlen(__sSlaveScript[i]),pfScr); // Write a line
dlp_fwrite("\n",1,1,pfScr); // Write a line break
} // <<
dlp_fclose(pfScr); // Close temporary script file
CDlpObject_Save(m_iDto,sDtoFn,SV_XML|SV_ZIP); // Save data transfer object
sprintf(m_psCmdLine,"%s %s %s",dlp_get_binary_path(),sScrFn,sDtoFn); // Change the command line
// -- ???? -->
IDESTROY(m_iDto); IFIELD_RESET(CDlpObject,"dto"); // Save memory!
// <----------
} // <<
m_nState |= PRC_DATASENT; // Remember data have been sent
return O_K;
}
/* Make up a new definition.
*/
Symbol *
workspace_add_def( Workspace *ws, const char *str )
{
Column *col = workspace_column_pick( ws );
Symbol *sym;
char *name;
#ifdef DEBUG
printf( "workspace_add_def: %s\n", str );
#endif /*DEBUG*/
if( !str || strspn( str, WHITESPACE ) == strlen( str ) )
return( NULL );
/* Try parsing as a "fred = 12" style def.
*/
attach_input_string( str );
if( (name = parse_test_define()) ) {
sym = symbol_new( ws->sym->expr->compile, name );
IM_FREE( name );
attach_input_string( str +
IM_CLIP( 0, input_state.charpos - 1, strlen( str ) ) );
}
else {
/* That didn't work. Make a sym from the col name.
*/
sym = workspace_add_symbol( ws );
attach_input_string( str );
}
if( !symbol_user_init( sym ) ||
!parse_rhs( sym->expr, PARSE_RHS ) ) {
/* Another parse error.
*/
expr_error_get( sym->expr );
/* Block changes to error_string ... symbol_destroy()
* can set this for compound objects.
*/
error_block();
IDESTROY( sym );
error_unblock();
return( NULL );
}
/* If we're redefining a sym, it might have a row already.
*/
if( !sym->expr->row )
(void) row_new( col->scol, sym, &sym->expr->root );
symbol_made( sym );
workspace_set_modified( ws, TRUE );
return( sym );
}
INT16 CGEN_PUBLIC CFBAproc::AlignFramesToPitch(CData *idPitch, CData *idFea, CData* idNewFea) {
CData* idAuxF = NULL;
INT32 nSamplesP = 0;
INT32 nFea = 0;
INT32 nPer = 0;
INT32 i = 0;
INT32 j = 0;
if(m_nSync) return O_K;
if(idFea == NULL) return IERROR(this,ERR_NULLINST,0,0,0);
if(idFea->IsEmpty()) return IERROR(idPitch,DATA_EMPTY,idPitch->m_lpInstanceName,0,0);
if(idPitch == NULL) return IERROR(this,ERR_NULLINST,0,0,0);
if(idPitch->IsEmpty()) return IERROR(idPitch,DATA_EMPTY,idPitch->m_lpInstanceName,0,0);
if(idPitch->GetNComps()!=2 ||
!dlp_is_numeric_type_code(idPitch->GetCompType(0)) ||
!dlp_is_numeric_type_code(idPitch->GetCompType(1))) {
return IERROR(this,FBA_BADARG,idPitch,"idPitch","contains invalid data.");
}
CREATEVIRTUAL(CData,idFea,idNewFea);
ICREATEEX(CData,idAuxF ,"~idAuxF" ,NULL);
if(idFea->m_lpTable->m_fsr <= 0.0) {
idFea->m_lpTable->m_fsr = 1000.0 * (FLOAT64)m_nCrate / (FLOAT64)m_nSrate;
}
nFea = idFea->GetNRecs();
for(i = 0, j = 0, nSamplesP = 0; i < idPitch->GetNRecs(); i++, nSamplesP+=nPer) {
nPer = (INT32)idPitch->Dfetch(i,0);
while((idFea->m_lpTable->m_fsr * (FLOAT64)(j+0.5)) < (1000.0 * (FLOAT64)nSamplesP / (FLOAT64)m_nSrate)) j++;
j = (j>=nFea) ? nFea-1 : j;
idAuxF->SelectRecs(idFea,j,1);
idNewFea->Cat(idAuxF);
}
IDESTROY(idAuxF);
DESTROYVIRTUAL(idFea, idNewFea);
return O_K;
}
/**
* <p>INTERNAL USE ONLY. This method is called by {@link -pool} to pool the
* statistics blocks contained in <code>idSrc</code> and store the result in
* <code>idPool</code>. The operation is controlled through the pooling mode
* flag <code>nMode</code> as follows:</p>
*
* <ul>
* <li>nMode=0: Pool sum data, <code>idPool</code> will be overwritten</li>
* <li>nMode=1: Pool min data</li>
* <li>nMode=2: Pool max data</li>
* </ul>
*
* <h3>Remarks</h3>
* <ul>
* <li>In order to pool raw statistics data, there are three calls
* (<code>nMode</code>=0,1 and 2) necessary. The first call of these
* <em>must</em> be the one with <code>nMode</code>=0!</li>
* <li>There are NO checks performed</li>
* </ul>
*
* @param idPool
* Pooled raw statistics data block
* @param idSrc
* Raw statistics data blocks to be pooled
* @param nMode
* Pooling mode, see above
*/
void CGEN_SPRIVATE CStatistics_PoolInt(CData* idPool, CData* idSrc, INT32 nMode)
{
CData* idAux = NULL; /* Auxilary data instance #1 */
if (nMode==0) /* Sum aggregation mode */
{ /* >> */
ISETOPTION(idPool,"/block"); /* Switch target to block mode */
CData_Aggregate(idPool,idSrc,NULL,CMPLX(0),"sum"); /* Aggregate (sum up) */
IRESETOPTIONS(idPool); /* Switch target to normal mode */
} /* << */
else if (nMode==1 || nMode==2) /* Extrama aggregation modes */
{ /* >> */
ICREATEEX(CData,idAux,"CStatistics_Pool_int.~idAux",NULL); /* Create auxilary data instance #1*/
ISETOPTION(idAux,"/block"); /* Switch target to block mode */
CData_Aggregate(idAux,idSrc,NULL,CMPLX(0),nMode==1?"min":"max"); /* Aggregate (minimum or maximum) */
dlp_memmove(CData_XAddr(idPool,nMode,0),CData_XAddr(idAux,nMode,0), /* Copy aggregated min. or max. ...*/
CData_GetRecLen(idAux)); /* | ... to target */
IRESETOPTIONS(idAux); /* Switch target to normal mode */
IDESTROY(idAux); /* Destroy auxilary data inst. #1 */
} /* << */
else /* Unknown mode */
DLPASSERT(FMSG("Invalid internal pooling mode")); /* Not so good ... */
}
static void
workspace_dispose( GObject *gobject )
{
Workspace *ws;
#ifdef DEBUG
printf( "workspace_dispose: %p %s\n",
gobject, NN( IOBJECT( gobject )->name ) );
#endif /*DEBUG*/
g_return_if_fail( gobject != NULL );
g_return_if_fail( IS_WORKSPACE( gobject ) );
ws = WORKSPACE( gobject );
workspace_set_needs_layout( ws, FALSE );
ws->in_dispose = TRUE;
UNREF( ws->kitg );
UNREF( ws->local_kitg );
IDESTROY( ws->sym );
G_OBJECT_CLASS( parent_class )->dispose( gobject );
}
/* DP decoder free function
*
* This function frees the internal memory of the decoder.
*
* @param glob Pointer to the global memory structure
*/
void fsts_sdp_free(struct fsts_glob *glob){
CFst *itDst=(CFst*)glob->algo;
if(!glob->algo) return;
IDESTROY(itDst);
glob->algo=NULL;
}
/**
* Analyse
*
* Derived instances of FBAproc should override method
* Analyse() to add the desired functionality
*
* @return O_K if successfull, NOT_EXEC otherwise
*/
INT16 CGEN_PUBLIC CCPproc::AnalyzeFrame() {
INT16 ret = O_K;
if(!strcmp(m_lpsType, "MelFilter")) {
CData* idCep = NULL;
CData* idMel = NULL;
ICREATEEX(CData, idCep, "~idCep", NULL);
ICREATEEX(CData, idMel, "~idMel", NULL);
if((ret = CMELproc::AnalyzeFrame()) != O_K) return ret;
idMel->Select(m_idRealFrame, 0, m_nCoeff);
if((ret = Mf2mcep(idMel, idCep, m_nCoeff)) != O_K) return ret;
dlp_memmove(m_idRealFrame->XAddr(0, 0), idCep->XAddr(0, 0), m_nCoeff * sizeof(FLOAT64));
IDESTROY(idMel);
IDESTROY(idCep);
} else {
if(!strcmp(m_lpsWarptype, "time")) {
if(!strcmp(m_lpsType, "BurgLPC")) {
dlm_calcmcep((FLOAT64*)m_idRealFrame->XAddr(0, 0), m_nWlen, (FLOAT64*)m_idRealFrame->XAddr(0, 0), m_nCoeff, 0.0, -m_nMinLog, DLM_CALCCEP_METHOD_S_MLPC_BURG_MCEP);
} else if(!strcmp(m_lpsType, "LevinsonLPC")) {
dlm_calcmcep((FLOAT64*)m_idRealFrame->XAddr(0, 0), m_nWlen, (FLOAT64*)m_idRealFrame->XAddr(0, 0), m_nCoeff, 0.0, -m_nMinLog, DLM_CALCCEP_METHOD_S_MLPC_LEVI_MCEP);
} else if(!strcmp(m_lpsType, "Uels")) {
dlm_calcmcep((FLOAT64*)m_idRealFrame->XAddr(0, 0), m_nLen, (FLOAT64*)m_idRealFrame->XAddr(0, 0), m_nCoeff, 0.0, -m_nMinLog, DLM_CALCCEP_METHOD_S_MCEP_UELS);
} else if(!strcmp(m_lpsType, "LogFFT")) {
dlp_memset(m_idImagFrame->XAddr(0, 0), 0L, m_nLen * sizeof(FLOAT64));
if((ret = dlm_fft((FLOAT64*)m_idRealFrame->XAddr(0, 0),(FLOAT64*)m_idImagFrame->XAddr(0, 0),m_nLen,FALSE)) != O_K) {
if(ret == ERR_MDIM) IERROR(this, FBA_BADFRAMELEN, m_nLen, "FFT", 0);
return NOT_EXEC;
}
LN();
if((ret = dlm_fft((FLOAT64*)m_idRealFrame->XAddr(0, 0), (FLOAT64*)m_idImagFrame->XAddr(0, 0), m_nLen, TRUE)) != O_K) {
if(ret == ERR_MDIM) IERROR(this, FBA_BADFRAMELEN, m_nLen, "FFT", 0);
return NOT_EXEC;
}
for(INT32 i = 1; i < m_nCoeff; i++) {
((FLOAT64*)m_idRealFrame->XAddr(0, 0))[i] *= 2.0;
}
} else {
IERROR(this,ERR_NULLINST,0,0,0);
return NOT_EXEC;
}
} else {
if(!strcmp(m_lpsType, "BurgLPC")) {
if(!strcmp(m_lpsWarptype, "lpc")) {
dlm_calcmcep((FLOAT64*)m_idRealFrame->XAddr(0, 0), m_nWlen, (FLOAT64*)m_idRealFrame->XAddr(0, 0),
m_nCoeff, m_nPfaLambda, -m_nMinLog, DLM_CALCCEP_METHOD_S_LPC_BURG_MLPC_MCEP);
} else if(!strcmp(m_lpsWarptype, "cepstrum")) {
dlm_calcmcep((FLOAT64*)m_idRealFrame->XAddr(0, 0), m_nWlen, (FLOAT64*)m_idRealFrame->XAddr(0, 0),
m_nCoeff, m_nPfaLambda, -m_nMinLog, DLM_CALCCEP_METHOD_S_LPC_BURG_CEP_MCEP);
} else if(!strcmp(m_lpsWarptype, "none")) {
dlm_calcmcep((FLOAT64*)m_idRealFrame->XAddr(0, 0), m_nWlen, (FLOAT64*)m_idRealFrame->XAddr(0, 0),
m_nCoeff, 0.0, -m_nMinLog, DLM_CALCCEP_METHOD_S_LPC_BURG_CEP);
} else {
IERROR(this, CP_WARPTYPE, m_lpsWarptype, 0, 0);
return NOT_EXEC;
}
} else if(!strcmp(m_lpsType, "LevinsonLPC")) {
if(!strcmp(m_lpsWarptype, "lpc")) {
dlm_calcmcep((FLOAT64*)m_idRealFrame->XAddr(0, 0), m_nWlen, (FLOAT64*)m_idRealFrame->XAddr(0, 0),
m_nCoeff, m_nPfaLambda, -m_nMinLog, DLM_CALCCEP_METHOD_S_LPC_LEVI_MLPC_MCEP);
} else if(!strcmp(m_lpsWarptype, "cepstrum")) {
dlm_calcmcep((FLOAT64*)m_idRealFrame->XAddr(0, 0), m_nWlen, (FLOAT64*)m_idRealFrame->XAddr(0, 0), m_nWlen
/ 2, m_nPfaLambda, -m_nMinLog, DLM_CALCCEP_METHOD_S_LPC_LEVI_CEP_MCEP);
} else if(!strcmp(m_lpsWarptype, "none")) {
dlm_calcmcep((FLOAT64*)m_idRealFrame->XAddr(0, 0), m_nWlen, (FLOAT64*)m_idRealFrame->XAddr(0, 0),
m_nCoeff, 0.0, -m_nMinLog, DLM_CALCCEP_METHOD_S_LPC_LEVI_CEP);
} else {
IERROR(this, CP_WARPTYPE, m_lpsWarptype, 0, 0);
return NOT_EXEC;
}
} else if(!strcmp(m_lpsType, "Uels")) {
if((ret = dlm_calcmcep((FLOAT64*)m_idRealFrame->XAddr(0, 0), m_nLen, (FLOAT64*)m_idRealFrame->XAddr(0, 0), m_nCoeff,
m_nPfaLambda, exp(-m_nMinLog), DLM_CALCCEP_METHOD_S_MCEP_UELS)) != O_K) {
return NOT_EXEC;
}
} else if(!strcmp(m_lpsType, "LogFFT")) {
dlp_memset(m_idImagFrame->XAddr(0, 0), 0L, m_nLen * sizeof(FLOAT64));
if((ret = dlm_fft((FLOAT64*)m_idRealFrame->XAddr(0, 0), (FLOAT64*)m_idImagFrame->XAddr(0, 0), m_nLen, FALSE)) != O_K) {
if(ret == ERR_MDIM) IERROR(this, FBA_BADFRAMELEN, m_nLen, "FFT", 0);
return NOT_EXEC;
}
LN();
if(!strcmp(m_lpsWarptype, "lpc")) {
IERROR(this, CP_WARPTYPE, m_lpsWarptype, 0, 0);
return NOT_EXEC;
} else if(!strcmp(m_lpsWarptype, "cepstrum")) {
dlp_memset(m_idImagFrame->XAddr(0, 0), 0L, m_nLen * sizeof(FLOAT64));
if((ret = dlm_fft((FLOAT64*)m_idRealFrame->XAddr(0, 0), (FLOAT64*)m_idImagFrame->XAddr(0, 0), m_nLen, TRUE)) != O_K) {
if(ret == ERR_MDIM) IERROR(this, FBA_BADFRAMELEN, m_nLen, "FFT", 0);
return NOT_EXEC;
}
dlm_cep2mcep((FLOAT64*)m_idRealFrame->XAddr(0, 0), m_nLen, (FLOAT64*)m_idRealFrame->XAddr(0, 0),
m_nCoeff, m_nPfaLambda, NULL);
} else if(!strcmp(m_lpsWarptype, "spectrum")) {
WARP();
dlp_memset(m_idImagFrame->XAddr(0, 0), 0L, m_nLen * sizeof(FLOAT64));
if((ret = dlm_fft((FLOAT64*)m_idRealFrame->XAddr(0, 0), (FLOAT64*)m_idImagFrame->XAddr(0, 0), m_nLen, TRUE)) != O_K) {
if(ret == ERR_MDIM) IERROR(this, FBA_BADFRAMELEN, m_nLen, "FFT", 0);
return NOT_EXEC;
}
} else if(!strcmp(m_lpsWarptype, "none")) {
dlp_memset(m_idImagFrame->XAddr(0, 0), 0L, m_nLen * sizeof(FLOAT64));
if((ret = dlm_fft((FLOAT64*)m_idRealFrame->XAddr(0, 0), (FLOAT64*)m_idImagFrame->XAddr(0, 0), m_nLen, TRUE)) != O_K) {
if(ret == ERR_MDIM) IERROR(this, FBA_BADFRAMELEN, m_nLen, "FFT", 0);
return NOT_EXEC;
}
} else {
IERROR(this,ERR_NULLINST,0,0,0);
}
for(INT32 i = 1; i < m_nCoeff; i++) {
((FLOAT64*)m_idRealFrame->XAddr(0, 0))[i] *= 2.0;
}
} else if(strcmp(m_lpsWarptype, "none")) {
IERROR(this,ERR_NULLINST,0,0,0);
}
}
}
return O_K;
}
/*
* Manual page at statistics.def
*/
INT16 CGEN_PUBLIC CStatistics_Pool
(
CStatistics* _this,
CStatistics* iSrc,
CData* idMap
)
{
INT32 i = 0; /* Current component index */
INT32 nC = 0; /* Current pooled statistics class */
INT32 nCs = 0; /* Current source class index */
INT32 nXC = 0; /* Number of pooled classes */
INT32 nRpb = 0; /* Statistics raw data block size */
INT16 nCheckSave = 0; /* Saved check level */
CData* idAux = NULL; /* Auxilary data instance #1 */
CData* idPmp = NULL; /* Pooling map */
CData* idPcd = NULL; /* Pooled class raw data buffer */
/* Initialize */ /* --------------------------------- */
CHECK_THIS_RV(0); /* Check this instance */
IF_NOK(CStatistics_Check(iSrc)) /* Check source statistics */
return IERROR(_this,ERR_INVALARG,"iSrc",0,0); /* ... */
nCheckSave = _this->m_nCheck; /* Save check level */
CStatistics_Reset(BASEINST(_this),TRUE); /* Reset destination */
_this->m_nCheck = nCheckSave; /* Restore check level */
IFIELD_RESET(CData,"dat"); /* Create pool raw stats. data inst. */
/* Protocol */ /* --------------------------------- */
IFCHECK /* On verbose level 1 */
{ /* >> */
printf("\n"); dlp_fprint_x_line(stdout,'-',dlp_maxprintcols()); /* Print protocol header */
printf("\n statistics -pool"); /* ... */
printf("\n"); dlp_fprint_x_line(stdout,'-',dlp_maxprintcols());printf("\n");/* ... */
} /* << */
/* No map --> pool all classes */ /* --------------------------------- */
if (CData_IsEmpty(idMap)) /* NULL or empty map instance */
{ /* >> */
IFCHECK printf("\n Empty pooling map --> pool all classes"); /* Protocol (verbose level 1) */
CStatistics_PoolInt(_this->m_idDat,iSrc->m_idDat,0); /* Pool sum data */
CStatistics_PoolInt(_this->m_idDat,iSrc->m_idDat,1); /* Pool min data */
CStatistics_PoolInt(_this->m_idDat,iSrc->m_idDat,2); /* Pool max data */
STA_PROTOCOL_FOOTER(1,"done"); /* Print protocol footer */
return O_K; /* That's it */
}
IFCHECK printf("\n Pooling by map"); /* Protocol (verbose level 1) */
ICREATEEX(CData,idAux,"CStatistics_Pool.~idAux",NULL); /* Create auxilary data instance #1 */
ICREATEEX(CData,idPmp,"CStatistics_Pool.~idPmp",NULL); /* Create pooling map */
ICREATEEX(CData,idPcd,"CStatistics_Pool.~idPcs",NULL); /* Create pooled raw stats.data inst.*/
/* Find and copy map component (pooled class) */ /* --------------------------------- */
for (i=0; i<CData_GetNComps(idMap); i++) /* Loop over components of idMap */
if (dlp_is_numeric_type_code(CData_GetCompType(idMap,i))) /* Is current component numeric? */
{ /* >> (Yes) */
CData_SelectComps(idPmp,idMap,i,1); /* Copy component */
break; /* Have ready :) */
} /* << */
if (CData_IsEmpty(idPmp)) /* Have not got map component */
{ /* >> */
IERROR(_this,STA_BADCOMP,"map",BASEINST(idMap)->m_lpInstanceName,"numeric");/* Error message */
DLPTHROW(STA_BADCOMP); /* Throw exception */
} /* << */
/* Create source class component */ /* --------------------------------- */
CData_AddComp(idPmp,"srcc",T_LONG); /* Add source class index component */
for (i=0; i<CData_GetNRecs(idPmp); i++) CData_Dstore(idPmp,i,i,1); /* Fill it */
/* Finish pooling map and initialize pooling */ /* --------------------------------- */
CData_Sortup(idPmp,idPmp,0); /* Sort map by pooled class index */
nXC = (INT32)CData_Dfetch(idPmp,CData_GetNRecs(idPmp)-1,0)+1; /* Get greatest pooled class index */
IFCHECK printf("\n Pooling %ld statistics classes",(long)nXC); /* Protocol (verbose level 1) */
IFCHECKEX(3) CData_Print(idPmp); /* Print pooling map (verbose lvl.3) */
nRpb = CData_GetNRecsPerBlock(iSrc->m_idDat); /* Get block size */
/* Prepare pooled statistics */ /* --------------------------------- */
CData_Scopy(_this->m_idDat,iSrc->m_idDat); /* Create target raw data components */
CData_Allocate(_this->m_idDat,nRpb*nXC); /* Allocate target raw data */
CData_SetNBlocks(_this->m_idDat,nXC); /* Set target statistics block number*/
/* Pooling loop */ /* --------------------------------- */
for (i=0; i<CData_GetNRecs(idPmp); ) /* Loop over pooling map */
{ /* >> */
/* - Copy raw statistics data of one pooled class */ /* - - - - - - - - - - - - - - - - */
nC = (INT32)CData_Dfetch(idPmp,0,0); /* Get pooled class index */
IFCHECK printf("\n Pooled class %3ld"); /* Protocol (verbose level 1) */
for (i=0; i<CData_GetNRecs(idPmp); i++) /* Loop over partition of pool.map */
{ /* >> */
if (nC != (INT32)CData_Dfetch(idPmp,0,0)) break; /* Not the current class anymore */
nCs = (INT32)CData_Dfetch(idPmp,i,1); /* Get source class index */
IFCHECK printf("\n - Source class %3ld",nCs); /* Protocol (verbose level 1) */
CData_SelectBlocks(idAux,iSrc->m_idDat,nCs,1); /* Copy raw stats. data block */
CData_Cat(idPcd,idAux); /* Append to buffer */
} /* << */
/* - Pool data */ /* - - - - - - - - - - - - - - - - */
CData_SetNBlocks(idPcd,CData_GetNRecs(idPcd)/nRpb); /* Set block count of aggr. buffer */
IFCHECK /* Protocol (verbose level 1) */
printf("\n - Aggregating %ld statistics classes", /* | */
(long)CData_GetNBlocks(idPcd)); /* | */
CStatistics_PoolInt(idAux,idPcd,0); /* Pool sum data */
CStatistics_PoolInt(idAux,idPcd,1); /* Pool min data */
CStatistics_PoolInt(idAux,idPcd,2); /* Pool max data */
/* - Store pooled raw statistics data block */ /* - - - - - - - - - - - - - - - - */
dlp_memmove /* Copy pooled raw stats. data */
( /* | */
CData_XAddr(_this->m_idDat,nC*nRpb,0), /* | To target statistics block */
CData_XAddr(idAux,0,0), /* | From aggregation buffer */
CData_GetNRecs(idAux)*CData_GetRecLen(idAux) /* | Length of aggregation buffer */
); /* | */
/* - Clean up auxilary instances */ /* - - - - - - - - - - - - - - - - */
CData_Reset(idPcd,TRUE); /* Clear aggregation buffer */
}
/* Clean up */ /* --------------------------------- */
IDESTROY(idAux); /* Destroy auxilary data instance #1 */
IDESTROY(idPmp); /* Destroy pooling map */
IDESTROY(idPcd); /* Destroy pooled cls. raw data inst.*/
STA_PROTOCOL_FOOTER(1,"done"); /* Print protocol footer */
return O_K; /* Ok */
DLPCATCH(STA_BADCOMP) /* == Catch STA_BADCOMP exception */
IDESTROY(idAux); /* Destroy auxilary data instance #1 */
IDESTROY(idPmp); /* Destroy pooling map */
IDESTROY(idPcd); /* Destroy pooled cls. raw data inst.*/
STA_PROTOCOL_FOOTER(1,"FAILED"); /* Print protocol footer */
return NOT_EXEC; /* Not ok */
}
/**
* Copies the one field from iSrc to this instance
*
* @param _this This (destination) instance
* @param lpWord Pointer to a SWord structure identifying the field to copy
* @param iSrc The source instance to copy the field from
* @return O_K if successful, an error code otherwise
*
* HACK: This implementation copies simple types and strings only!!!
* TODO: Implement instance and pointer copying
*/
INT16 CDlpObject_CopyField(CDlpObject* _this, SWord* lpWord, CDlpObject* iSrc)
{
SWord* lpWordSrc = NULL;
/* Validate input */
CHECK_THIS_RV(NOT_EXEC);
if (!lpWord) return NOT_EXEC;
if (!iSrc ) return NOT_EXEC;
if (lpWord->nFlags & (FF_NONAUTOMATIC|FF_NOSAVE)) return NOT_EXEC;
/* Get source word */
lpWordSrc = CDlpObject_FindWord(iSrc,lpWord->lpName,WL_TYPE_FIELD);
DLPASSERT(lpWordSrc); /* Instance type? */
DLPASSERT(lpWord->nWordType ==lpWordSrc->nWordType ); /* Field overwritten? */
DLPASSERT(lpWord->ex.fld.nType==lpWordSrc->ex.fld.nType); /* Field overwritten? */
/*printf("\n Copy field %s.%s --> %s.%s",BASEINST(iSrc)->m_lpInstanceName,lpWord->lpName,BASEINST(_this)->m_lpInstanceName,lpWord->lpName);*/
/* Copy data */
switch (lpWord->ex.fld.nType)
{
case T_BOOL : dlp_memmove(lpWord->lpData,lpWordSrc->lpData,sizeof( BOOL)); return O_K;
case T_UCHAR : dlp_memmove(lpWord->lpData,lpWordSrc->lpData,sizeof( UINT8)); return O_K;
case T_CHAR : dlp_memmove(lpWord->lpData,lpWordSrc->lpData,sizeof( INT8)); return O_K;
case T_USHORT : dlp_memmove(lpWord->lpData,lpWordSrc->lpData,sizeof( UINT16)); return O_K;
case T_SHORT : dlp_memmove(lpWord->lpData,lpWordSrc->lpData,sizeof( INT16)); return O_K;
case T_UINT : dlp_memmove(lpWord->lpData,lpWordSrc->lpData,sizeof( UINT32)); return O_K;
case T_INT : dlp_memmove(lpWord->lpData,lpWordSrc->lpData,sizeof( INT32)); return O_K;
case T_ULONG : dlp_memmove(lpWord->lpData,lpWordSrc->lpData,sizeof( UINT64)); return O_K;
case T_LONG : dlp_memmove(lpWord->lpData,lpWordSrc->lpData,sizeof( INT64)); return O_K;
case T_FLOAT : dlp_memmove(lpWord->lpData,lpWordSrc->lpData,sizeof( FLOAT32)); return O_K;
case T_DOUBLE : dlp_memmove(lpWord->lpData,lpWordSrc->lpData,sizeof( FLOAT64)); return O_K;
case T_COMPLEX: dlp_memmove(lpWord->lpData,lpWordSrc->lpData,sizeof(COMPLEX64)); return O_K;
case T_STRING :
case T_CSTRING:
case T_TEXT :
dlp_free(*(char**)lpWord->lpData);
*(char**)lpWord->lpData = NULL;
if (*(char**)lpWordSrc->lpData)
{
*(char**)lpWord->lpData = (char*)dlp_malloc(dlp_size(*(char**)lpWordSrc->lpData));
dlp_strcpy(*(char**)lpWord->lpData,*(char**)lpWordSrc->lpData);
}
return O_K;
case T_INSTANCE:
if (*(CDlpObject**)lpWordSrc->lpData)
{
if (*(CDlpObject**)lpWord->lpData==NULL)
{
#ifdef __cplusplus
*(CDlpObject**)lpWord->lpData = CDlpObject_CreateInstanceOf(lpWordSrc->ex.fld.lpType,lpWordSrc->lpName);
#else
*(CDlpObject**)lpWord->lpData = *(CDlpObject**)CDlpObject_CreateInstanceOf(lpWordSrc->ex.fld.lpType,lpWordSrc->lpName);
#endif
if (!*(CDlpObject**)lpWord->lpData)
IERROR(_this,ERR_CREATEINSTANCE,lpWord->lpName,0,0);
else
(*(CDlpObject**)lpWord->lpData)->m_lpContainer=lpWord;
}
#ifdef __cplusplus
return (*(CDlpObject**)lpWord->lpData)->Copy(*(CDlpObject**)lpWordSrc->lpData);
#else
return (*(CDlpObject**)lpWord->lpData)->Copy(*(CDlpObject**)lpWord->lpData,*(CDlpObject**)lpWordSrc->lpData);
#endif
}
else if (*(CDlpObject**)lpWord->lpData)
{
IDESTROY((*(CDlpObject**)lpWord->lpData));
}
default:
if (lpWord->ex.fld.nType>0 && lpWord->ex.fld.nType<=255)
{
dlp_memmove(lpWord->lpData,lpWordSrc->lpData,lpWord->ex.fld.nType);
return O_K;
}
return NOT_EXEC;
}
}
INT16 CGEN_PUBLIC CFBAproc::AdjustSpeechRate(CData *idPitch, CData *idNewPitch, CData* idFea, CData* idNewFea, FLOAT32 rate) {
INT16 bVoiced = FALSE;
INT32 i = 0;
INT32 k = 0;
INT32 nCount = 0;
INT32 nStartL = 0;
FLOAT32 nMeanPeriodLengthL = 0.0;
FLOAT32 nMeanPeriodLength = 0.0;
CData* idVoiced = NULL;
CData* idAuxP = NULL;
CData* idAuxF = NULL;
// Validation
if(idPitch == NULL) return IERROR(this,ERR_NULLINST,0,0,0);
if(idPitch->IsEmpty()) return IERROR(idPitch,DATA_EMPTY,idPitch->m_lpInstanceName,0,0);
if
(
idPitch->GetNComps()!=2 ||
!dlp_is_numeric_type_code(idPitch->GetCompType(0)) ||
!dlp_is_numeric_type_code(idPitch->GetCompType(1))
)
{
return IERROR(this,FBA_BADARG,idPitch,"idPitch","contains invalid data.");
}
// Initialization
CREATEVIRTUAL(CData,idPitch,idNewPitch);
CREATEVIRTUAL(CData,idFea,idNewFea);
ICREATEEX(CData,idVoiced,"~idVoiced",NULL);
ICREATEEX(CData,idAuxP ,"~idAuxP" ,NULL);
ICREATEEX(CData,idAuxF ,"~idAuxF" ,NULL);
idNewPitch->Reset();
idVoiced->AddComp("start",T_INT);
idVoiced->AddComp("count",T_INT);
idVoiced->AddComp("mplen",T_FLOAT);
idVoiced->Alloc(10);
AlignFramesToPitch(idPitch, idFea, idFea);
// Determine start and length of voiced parts and mean of periods in samples
for(i=0; i<idPitch->GetNRecs(); i++)
{
if(idPitch->Dfetch(i,1)>0)
{
if(bVoiced==FALSE) // Start of new voiced segment
{
bVoiced=TRUE;
nStartL=i;
nMeanPeriodLengthL=0;
if(idVoiced->GetNRecs()==idVoiced->GetMaxRecs())
idVoiced->Realloc(idVoiced->GetNRecs()+10);
idVoiced->IncNRecs(1);
idVoiced->Dstore(i,idVoiced->GetNRecs()-1,0);
}
nMeanPeriodLength+=(INT32)idPitch->Dfetch(i,0);
nMeanPeriodLengthL+=(INT32)idPitch->Dfetch(i,0);
nCount++;
}
else if(bVoiced==TRUE) // End of voiced segment
{
bVoiced=FALSE;
nMeanPeriodLengthL=nMeanPeriodLengthL/(FLOAT32)(i-nStartL);
idVoiced->Dstore(i-nStartL,idVoiced->GetNRecs()-1,1);
idVoiced->Dstore(nMeanPeriodLengthL,idVoiced->GetNRecs()-1,2);
}
}
nMeanPeriodLength=nMeanPeriodLength/(FLOAT32)nCount;
IFCHECK idVoiced->Print();
IFCHECK printf("\n Input mean period length in voiced parts: %f",nMeanPeriodLength);
// Resample
for(i=0,nStartL=0; i<idVoiced->GetNRecs(); i++)
{
INT32 j = 0;
INT32 nSum = 0;
INT32 nRecOld = 0;
INT32 nRecNew = 0;
// Copy unvoiced
idAuxP->SelectRecs(idPitch,nStartL,(INT32)idVoiced->Dfetch(i,0)-nStartL);
idNewPitch->Cat(idAuxP);
idAuxF->SelectRecs(idFea,nStartL,(INT32)idVoiced->Dfetch(i,0)-nStartL);
idNewFea->Cat(idAuxF);
nStartL=(INT32)idVoiced->Dfetch(i,0)+(INT32)idVoiced->Dfetch(i,1);
// Resample voiced
idAuxP->SelectRecs(idPitch,(INT32)idVoiced->Dfetch(i,0),(INT32)idVoiced->Dfetch(i,1));
nRecOld = idAuxP->GetNRecs();
for(j=0,nSum=0;j<nRecOld;j++) nSum+=(INT32)idAuxP->Dfetch(j,0); // Target sum
idAuxP->Resample(idAuxP, rate);
nRecNew = idAuxP->GetNRecs();
for(j=0;j<nRecNew;j++) {
INT32 tmp = (INT32)idAuxP->Dfetch(j,0);
tmp = (INT32)MAX(m_nSrate/500, tmp);
tmp = (INT32)MIN(m_nSrate/50, tmp);
idAuxP->Dstore(tmp,j,0);
}
//idAux->Fill_Int(1.0,0.0,1);
for(k=0;k<nRecNew;k++) idAuxP->Dstore(1.0,k,1);
for(k=0;k<nRecNew;k++) {
j = (INT32)((FLOAT64)k * (FLOAT64)nRecOld / (FLOAT64)nRecNew + 0.5);
idAuxF->SelectRecs(idFea,j+(INT32)idVoiced->Dfetch(i,0),1);
idNewFea->Cat(idAuxF);
}
idNewPitch->Cat(idAuxP);
}
// Append last unvoiced segment
nStartL = (INT32)idVoiced->Dfetch(idVoiced->GetNRecs()-1,0)+(INT32)idVoiced->Dfetch(idVoiced->GetNRecs()-1,1);
idAuxP->SelectRecs(idPitch,nStartL,idPitch->GetNRecs()-nStartL);
idNewPitch->Cat(idAuxP);
idAuxF->SelectRecs(idFea,nStartL,idPitch->GetNRecs()-nStartL);
idNewFea->Cat(idAuxF);
DESTROYVIRTUAL(idPitch,idNewPitch);
DESTROYVIRTUAL(idFea,idNewFea);
IDESTROY(idVoiced);
IDESTROY(idAuxP);
IDESTROY(idAuxF);
return O_K;
}
static void
row_dispose( GObject *gobject )
{
Row *row = ROW( gobject );
#ifdef DEBUG_NEW
/* Can't use row_name_print(), we may not have a parent.
*/
printf( "row_dispose: %s", NN( IOBJECT( row )->name ) );
if( row->sym )
printf( " (%s)", symbol_name( row->sym ) );
printf( "\n" );
#endif /*DEBUG_NEW*/
/* Reset state. Also see row_parent_remove().
*/
row_hide_dependents( row );
if( row->expr )
expr_error_clear( row->expr );
if( row->top_col && row->top_col->last_select == row )
row->top_col->last_select = NULL;
row_deselect( row );
/* Break all recomp links.
*/
slist_map( row->parents, (SListMapFn) row_link_break, row );
slist_map( row->children, (SListMapFn) row_link_break_rev, row );
g_assert( !row->parents && !row->children );
(void) slist_map( row->recomp, (SListMapFn) row_dirty_clear, NULL );
if( row->top_row )
row->top_row->recomp_save =
g_slist_remove( row->top_row->recomp_save, row );
IM_FREEF( g_slist_free, row->recomp_save );
g_assert( !row->recomp );
if( row->expr ) {
g_assert( row->expr->row == row );
/* If we're a local row, we will have a private expr
* allocated for us. Junk it.
*/
if( row != row->top_row )
icontainer_child_remove( ICONTAINER( row->expr ) );
else {
/* Top-level row, we were zapping the sym's expr.
* Break the link to it.
*/
row->expr->row = NULL;
row->expr = NULL;
}
}
/* Is this a top-level row? Kill the symbol too. Need to do this after
* sorting out row->expr, since otherwise killing the symbol will kill
* us again in turn.
*/
if( row == row->top_row )
IDESTROY( row->sym );
G_OBJECT_CLASS( parent_class )->dispose( gobject );
}
/*
* Resample voiced parts of pitch to match a given mean fundamential frequency.
* The length of voiced segments is preserved to avoid loss of synchronization
* between pitch and corresponding signal
*
* @param idPitch Source data instance containing original pitch
* @param idNewPitch Target data instance containing new pitch
* @param nFFreq Target fundamential frequency (mean over voiced parts)
*/
INT16 CGEN_PUBLIC CFBAproc::ResamplePitch(CData *idPitch, CData *idNewPitch, INT32 nFFreq)
{
INT16 bVoiced = FALSE;
INT32 i = 0;
INT32 k = 0;
INT32 nCount = 0;
INT32 nStartL = 0;
FLOAT32 nTargetPeriodLength = (FLOAT32)m_nSrate/(FLOAT32)nFFreq;
FLOAT32 nMeanPeriodLengthL = 0.0;
FLOAT32 nMeanPeriodLength = 0.0;
CData* idVoiced = NULL;
CData* idAux = NULL;
// Validation
if(idPitch == NULL) return IERROR(this,ERR_NULLINST,0,0,0);
if(idPitch->IsEmpty()) return IERROR(idPitch,DATA_EMPTY,idPitch->m_lpInstanceName,0,0);
if(nFFreq<50||nFFreq>500) return IERROR(this,FBA_BADARG,nFFreq,"nFFreq","a value between 50 and 500");
if
(
idPitch->GetNComps()!=2 ||
!dlp_is_numeric_type_code(idPitch->GetCompType(0)) ||
!dlp_is_numeric_type_code(idPitch->GetCompType(1))
)
{
return IERROR(this,FBA_BADARG,idPitch,"idPitch","contains invalid data.");
}
// Initialization
CREATEVIRTUAL(CData,idPitch,idNewPitch);
ICREATEEX(CData,idVoiced,"~idVoiced",NULL);
ICREATEEX(CData,idAux ,"~idAux" ,NULL);
idNewPitch->Reset();
idVoiced->AddComp("start",T_INT);
idVoiced->AddComp("count",T_INT);
idVoiced->AddComp("mplen",T_FLOAT);
idVoiced->Alloc(10);
// Determine start and length of voiced parts and mean of periods in samples
for(i=0; i<idPitch->GetNRecs(); i++)
{
if(idPitch->Dfetch(i,1)>0)
{
if(bVoiced==FALSE) // Start of new voiced segment
{
bVoiced=TRUE;
nStartL=i;
nMeanPeriodLengthL=0;
if(idVoiced->GetNRecs()==idVoiced->GetMaxRecs())
idVoiced->Realloc(idVoiced->GetNRecs()+10);
idVoiced->IncNRecs(1);
idVoiced->Dstore(i,idVoiced->GetNRecs()-1,0);
}
nMeanPeriodLength+=(INT32)idPitch->Dfetch(i,0);
nMeanPeriodLengthL+=(INT32)idPitch->Dfetch(i,0);
nCount++;
}
else if(bVoiced==TRUE) // End of voiced segment
{
bVoiced=FALSE;
nMeanPeriodLengthL=nMeanPeriodLengthL/(FLOAT32)(i-nStartL);
idVoiced->Dstore(i-nStartL,idVoiced->GetNRecs()-1,1);
idVoiced->Dstore(nMeanPeriodLengthL,idVoiced->GetNRecs()-1,2);
}
}
nMeanPeriodLength=nMeanPeriodLength/(FLOAT32)nCount;
IFCHECK idVoiced->Print();
IFCHECK printf("\n Input mean period length in voiced parts: %f",nMeanPeriodLength);
IFCHECK printf("\n Target mean period length: %f",nTargetPeriodLength);
// Resample
for(i=0,nStartL=0; i<idVoiced->GetNRecs(); i++)
{
INT32 j = 0;
INT32 nSum = 0;
INT32 nSumNew = 0;
INT32 nDiff = 0;
// Copy unvoiced
idAux->SelectRecs(idPitch,nStartL,(INT32)idVoiced->Dfetch(i,0)-nStartL);
idNewPitch->Cat(idAux);
nStartL=(INT32)idVoiced->Dfetch(i,0)+(INT32)idVoiced->Dfetch(i,1);
// Resample voiced
idAux->SelectRecs(idPitch,(INT32)idVoiced->Dfetch(i,0),(INT32)idVoiced->Dfetch(i,1));
for(j=0,nSum=0;j<idAux->GetNRecs();j++) nSum+=(INT32)idAux->Dfetch(j,0); // Target sum
idAux->Resample(idAux,nMeanPeriodLength/nTargetPeriodLength);
idAux->Tconvert(idAux,T_FLOAT);
idAux->Scalop(idAux,CMPLX(nTargetPeriodLength/nMeanPeriodLength),"mult");
idAux->Tconvert(idAux,T_INT);
//DLPASSERT(FALSE);
do
{
nSumNew=0;
for(j=0,nSumNew=0;j<idAux->GetNRecs();j++)
nSumNew+=(INT32)idAux->Dfetch(j,0); // New sum
nDiff=nSumNew-nSum; // Distribute difference
IFCHECK printf("\n Distribute difference d=%ld",(long)nDiff);
for(j=0;j<idAux->GetNRecs()&&j<abs(nDiff);j++)
{
INT32 nValue = (INT32)idAux->Dfetch(j,0);
if(nDiff<0) nValue+=1;
else if(nDiff>0) nValue-=1;
idAux->Dstore(nValue,j,0);
}
}
while(nDiff!=0);
//idAux->Fill_Int(1.0,0.0,1);
for(k=0;k<idAux->GetNRecs();k++) idAux->Dstore(1.0,k,1);
idNewPitch->Cat(idAux);
}
// Append last unvoiced segment
nStartL = (INT32)idVoiced->Dfetch(idVoiced->GetNRecs()-1,0)+(INT32)idVoiced->Dfetch(idVoiced->GetNRecs()-1,1);
idAux->SelectRecs(idPitch,nStartL,idPitch->GetNRecs()-nStartL);
idNewPitch->Cat(idAux);
DESTROYVIRTUAL(idPitch,idNewPitch);
IDESTROY(idVoiced);
IDESTROY(idAux);
return O_K;
}
INT16 CGmm_PrecalcD(CGmm* _this, BOOL bCleanup)
#endif
{
INT32 i = 0; /* Triangular inv. cov. matrix cntr. */
INT32 c = 0; /* Index of inv. covariance matrix */
INT32 k = 0; /* Gaussian loop counter */
INT32 n = 0; /* Dimension loop counter */
INT32 m = 0; /* Dimension loop counter */
INT32 K = 0; /* Number of single Gaussians */
INT32 N = 0; /* Feature space dimensionality */
GMM_FTYPE nDelta1 = 0.; /* Class indep. term of delta const. */
#ifdef __TMS
GMM_FTYPE *mean = (GMM_FTYPE*)CData_XAddr(AS(CData,_this->m_idMean),0,0);
#endif
/* Clean up precalculated data */ /* --------------------------------- */
dlp_free(_this->m_lpAlpha); /* Clear alpha vector */
dlp_free(_this->m_lpBeta ); /* Clear beta vectors */
dlp_free(_this->m_lpGamma); /* Clear gamma vector */
dlp_free(_this->m_lpDelta); /* Clear delta vector */
dlp_free(_this->m_lpI ); /* Clear inv. cov. pointer array */
dlp_free(_this->m_lpV ); /* Clear inverse variance array */
if(_this->m_idSse2Icov){
CData *idSse2Icov=AS(CData,_this->m_idSse2Icov);
IDESTROY(idSse2Icov); /* Destroy inv.covs. for SSE2 opt. */
_this->m_idSse2Icov=NULL;
}
dlp_free(_this->m_lpSse2Buf); /* Clear aux. buffer for SSE2 opt. */
dlp_free(_this->m_lpLdlL); /* Clear L-matrix buffer for LDL */
dlp_free(_this->m_lpLdlD); /* Clear D-vector buffer for LDL */
_this->m_nN = 0; /* Clear feature space dimensionality*/
_this->m_nK = 0; /* Clear number of single Gaussians */
if (bCleanup) return O_K; /* When cleaning up that's it */
/* Initialize */ /* --------------------------------- */
K = CGmm_GetNGauss(_this); /* Get nuumber of single Gaussians */
N = CGmm_GetDim(_this); /* Get feature space dimensionality */
nDelta1 = -N/2*log(2*F_PI); /* Compute part of delta term */
/* Basic validation */ /* --------------------------------- */
IF_NOK(CGmm_CheckMean(_this)) DLPTHROW(GMM_NOTSETUP); /* Check mean vectors */
IF_NOK(CGmm_CheckIvar(_this)) DLPTHROW(GMM_NOTSETUP); /* Check inverse variance vectors */
IF_NOK(CGmm_CheckCdet(_this)) DLPTHROW(GMM_NOTSETUP); /* Check (co-)variance determinants */
/* Basic dimensions */ /* --------------------------------- */
_this->m_nN = N; /* Feature space dimensionality */
_this->m_nK = K; /* Number of single Gaussians */
/* Create inverse covariance matrix map */ /* --------------------------------- */
if (_this->m_idIcov) /* If using covariances */
{ /* >> */
IF_NOK(CGmm_CheckIcov(_this)) DLPTHROW(GMM_NOTSETUP); /* Inverse covariance data corrupt */
_this->m_lpI = dlp_calloc(K,sizeof(GMM_FTYPE*)); /* Allocate map */
if (!_this->m_lpI) DLPTHROW(ERR_NOMEM); /* Out of memory */
for (k=0; k<K; k++) /* Loop over Gaussians */
{ /* >> */
c=_this->m_idCmap ? (INT32)CData_Dfetch(AS(CData,_this->m_idCmap),k,0) : k;/* Cov. mat. idx. for Gaussian k */
I[k] = (GMM_FTYPE*)CData_XAddr(AS(CData,_this->m_idIcov),c,0); /* Store ptr. to inv. cov. matrix*/
} /* << */
} /* << */
/* Create inverse variance vector map */ /* --------------------------------- */
IF_NOK(CGmm_CheckIvar(_this)) DLPTHROW(GMM_NOTSETUP); /* Inverse covariance data corrupt */
_this->m_lpV = dlp_calloc(K,sizeof(GMM_FTYPE*)); /* Allocate map */
if (!_this->m_lpV) DLPTHROW(ERR_NOMEM); /* Out of memory */
for (k=0; k<K; k++) /* Loop over Gaussians */
V[k] = (GMM_FTYPE*)CData_XAddr(AS(CData,_this->m_idIvar),k,0); /* Store ptr. to inv. cov. matrix*/
/* LDL-factorization */ /* --------------------------------- */
if(_this->m_nLDL) /* LDL factorization used */
{ /* >> */
/* TODO: GMM_TYPE is float => dlm_factldl in float */ /* ------------------------------- */
_this->m_lpLdlL = dlp_malloc(K*N*(N-1)/2*sizeof(GMM_FTYPE)); /* Alloc L matrix */
_this->m_lpLdlD = dlp_malloc(K*N*sizeof(GMM_FTYPE)); /* Alloc D vector */
if (!_this->m_lpLdlL || !_this->m_lpLdlD) DLPTHROW(ERR_NOMEM); /* Out of memory */
{
FLOAT64 *lpAux1 = (FLOAT64 *)dlp_malloc(N*N*sizeof(FLOAT64)); /* Alloc auxilary matrix #1 */
FLOAT64 *lpAux2 = (FLOAT64 *)dlp_malloc(N*N*sizeof(FLOAT64)); /* Alloc auxilary matrix #2 */
if (!lpAux1 || !lpAux2) DLPTHROW(ERR_NOMEM); /* Out of memory */
for(k=0;k<K;k++) /* Loop over all Gaussians */
{ /* >> */
for(n=0;n<N;n++) /* Loop over Gaussian dimension */
{ /* >> */
lpAux1[n*N+n] = V[k][n]; /* Copy inverse variance values*/
for(m=0;m<n;m++) lpAux1[n*N+m] = lpAux1[m*N+n] = /* Copy inverse covariance val.*/
I?I[k][m*N-2*m-m*(m-1)/2+n-1]:0.; /* | */
} /* << */
dlm_factldl(lpAux1,lpAux2,N); /* Factorize matrix */
for(n=0;n<N;n++) /* Loop over Gaussian dimension */
{ /* >> */
for(m=n+1;m<N;m++) Li(N,k,n,m) = lpAux1[n*N+m]; /* Store L matrix values */
D(N,k,n) = lpAux2[n*N+n]; /* Store D vector values */
} /* << */
if(_this->m_nLdlCoef>=0 && _this->m_nLdlCoef<N*(N-1)/2)
{
FLOAT64 nMinAbs;
memcpy(lpAux1,&L(N,k,0),N*(N-1)/2);
#if GMM_FTYPE_CODE == T_FLOAT
qsort(lpAux1,N*(N-1)/2,sizeof(FLOAT64),cf_absfloat_down);
#else
qsort(lpAux1,N*(N-1)/2,sizeof(FLOAT64),cf_absdouble_down);
#endif
nMinAbs=fabs(lpAux1[_this->m_nLdlCoef]);
for(n=0;n<N*(N-1)/2;n++) if(fabs(L(N,k,n))<=nMinAbs) L(N,k,n)=0.;
}
} /* << */
dlp_free(lpAux1); /* Free auxilary matrix #1 */
dlp_free(lpAux2); /* Free auxilary matrix #2 */
}
} /* << */
/* Precalculate alpha and beta vectors */ /* --------------------------------- */
if(!_this->m_nLDL) /* No LDL factorization used */
{ /* >> */
_this->m_lpAlpha = dlp_calloc(K,sizeof(GMM_FTYPE)); /* Allocate buffer */
_this->m_lpBeta = dlp_calloc(K*N,sizeof(GMM_FTYPE)); /* Allocate buffer */
if (!_this->m_lpAlpha || !_this->m_lpBeta) DLPTHROW(ERR_NOMEM); /* Out of memory */
for (k=0; k<K; k++) /* Loop over Gaussians */
for (n=0; n<N; n++) /* Loop over dimensions */
for (m=0; m<N; m++) /* Loop over dimensions */
if (m==n) /* Main diagonal (variances)?*/
{ /* >> */
alpha[k] += V[k][n]*mu(k,m)*mu(k,n); /* Sum up alpha val. (n==m)*/
beta [k*N+n] += V[k][n]*mu(k,m); /* Sum up beta value (n==m)*/
} /* << */
else if (_this->m_lpI) /* Otherwise cov.(if present)*/
{ /* >> */
if (m>n) i = n*N - 2*n - n*(n-1)/2 + m - 1; /* Calc index if I[n,m] in */
else i = m*N - 2*m - m*(m-1)/2 + n - 1; /* | triangular icov. mat. */
alpha[k] += I[k][i]*mu(k,m)*mu(k,n); /* Sum up alpha val. (n!=m)*/
beta [k*N+n] += I[k][i]*mu(k,m); /* Sum up beta value (n!=m)*/
} /* << */
} /* << */
else /* LDL factorization used */
{ /* >> */
_this->m_lpAlpha = NULL; /* No alpha needed here */
_this->m_lpBeta = dlp_calloc(K*N,sizeof(GMM_FTYPE)); /* Allocate buffer */
if (!_this->m_lpBeta) DLPTHROW(ERR_NOMEM); /* Out of memory */
for(k=0;k<K;k++) for(n=0;n<N;n++) /* Loop over Gaussians & dimensions*/
{ /* >> */
beta[k*N+n] = mu(k,n); /* Init beta with mean value */
for(m=n+1;m<N;m++) beta[k*N+n] += mu(k,m)*Li(N,k,n,m); /* Calculate beta from L*mu */
} /* << */
} /* << */
/* Allocate gamma vector */ /* --------------------------------- */
/* NOTE: If this fails there will just be no lazy computation -> no big deal*//* */
if (_this->m_idCmap && _this->m_idIcov && _this->m_lpI) /* Wanna do lazy computation? */
if (CData_GetDescr(AS(CData,_this->m_idIvar),0)==0.) /* Only if variances are tied too */
_this->m_lpGamma = dlp_calloc(K,sizeof(GMM_FTYPE)); /* Allocate buffer */
/* Precalculate delta vector */ /* --------------------------------- */
_this->m_lpDelta = dlp_calloc(K,sizeof(GMM_FTYPE)); /* Allocate buffer */
if (!_this->m_lpDelta) DLPTHROW(ERR_NOMEM); /* Out of memory */
for (k=0; k<K; k++) /* Loop over Gaussians */
delta[k] = nDelta1-(GMM_FTYPE)(0.5*log( /* Calculate delta[k] */
CData_Dfetch(AS(CData,_this->m_idCdet),k,0))); /* | */
/* SSE2 precalculated objects */ /* --------------------------------- */
#ifdef GMM_SSE2 /* Use SSE2? */
IFIELD_RESET(CData,"sse2_icov"); /* Create/reset SSE2 inv.cov. matrs. */
CGmm_Extract(_this,NULL,_this->m_idSse2Icov); /* ... and go get 'em */
_this->m_lpSse2Buf = dlp_calloc(2*N,sizeof(GMM_FTYPE)); /* Allocate auxilary buffer */
if (!_this->m_lpSse2Buf) DLPTHROW(ERR_NOMEM); /* Out of memory */
#endif /* #ifdef GMM_SSE2 */
/* Final checkup */ /* --------------------------------- */
#ifndef __NOXALLOC
IF_NOK(CGmm_CheckPrecalc(_this)) DLPTHROW(GMM_NOTSETUP); /* Check precalculated data */
#endif
return O_K; /* That's it folks ... */
DLPCATCH(GMM_NOTSETUP) /* On NOT_EXEC exception */
DLPCATCH(ERR_NOMEM) /* On ERR_NOMEM exception */
#if GMM_FTYPE_CODE == T_FLOAT
CGmm_PrecalcF(_this,TRUE); /* - Free memory of precalc'd. data */
#else
CGmm_PrecalcD(_this,TRUE); /* - Free memory of precalc'd. data */
#endif
return NOT_EXEC; /* - Indicate failure */
}
/*
* Manual page at fst_man.def
*/
INT16 CGEN_PUBLIC CFst_Rcs(CFst* _this, INT32 nUnit, FLOAT64 nSeed)
{
#ifdef __UNENTANGLE_FST
return IERROR(_this,FST_INTERNAL,__FILE__,__LINE__,0);
/* NOTE: __UNENTANGLE_FST was defined (probably in dlp_config.h or fst.def).
* Undefine it to use this feature!
*/
#else /* #ifdef __UNENTANGLE_FST */
INT32 nU = 0; /* Current unit */
FST_ITYPE nS = 0; /* Current state */
FST_ITYPE nS2 = 0; /* Current state */
FST_ITYPE nFS = 0; /* First state of current unit */
FST_ITYPE nXS = 0; /* Number of states of current unit */
FST_ITYPE nT = 0; /* Current transition */
FST_ITYPE nFT = 0; /* First transition of current unit */
FST_ITYPE nXT = 0; /* Number of tran. of current unit */
CData* idP = NULL; /* Incidence matrix */
CData* idB = NULL; /* Constanct vector of (idP-E)idX=idB */
CData* idI = NULL; /* idI = (idP-E)^-1 */
CData* idX = NULL; /* Solution of (idP-E)idX=idB */
FST_WTYPE nPSum = 0.; /* Probability sum/state */
INT32 nIcW = -1; /* Index of probability comp. in td */
INT32 nIcRcs = -1; /* Index of ref. counter comp. in sd */
INT32 nIcRct = -1; /* Index of ref. counter comp. in td */
/* Validation */
CHECK_THIS_RV(NOT_EXEC);
CFst_Check(_this);
if (CFst_Wsr_GetType(_this,&nIcW)!=FST_WSR_PROB)
return IERROR(_this,FST_MISS,"transition probability component",NC_TD_PSR,"transition table");
/* Initialize - Find or add reference counters */
nIcRcs = CData_FindComp(AS(CData,_this->sd),NC_SD_RC);
nIcRct = CData_FindComp(AS(CData,_this->td),NC_TD_RC);
if (nIcRcs<0)
{
CData_AddComp(AS(CData,_this->sd),NC_SD_RC,DLP_TYPE(FST_WTYPE));
nIcRcs = CData_GetNComps(AS(CData,_this->sd))-1;
}
if (nIcRct<0)
{
CData_AddComp(AS(CData,_this->td),NC_TD_RC,DLP_TYPE(FST_WTYPE));
nIcRct = CData_GetNComps(AS(CData,_this->td))-1;
}
/* Initialize - Create auxilary instances */
ICREATEEX(CData,idP,"~CFst_Reverse.idP",NULL);
ICREATEEX(CData,idB,"~CFst_Reverse.idB",NULL);
ICREATEEX(CData,idI,"~CFst_Reverse.idI",NULL);
ICREATEEX(CData,idX,"~CFst_Reverse.idX",NULL);
/* Loop over units */
for (nU=nUnit<0?0:nUnit; nU<UD_XXU(_this); nU++)
{
CData_Reset(BASEINST(idP),TRUE);
CData_Reset(BASEINST(idB),TRUE);
CData_Reset(BASEINST(idI),TRUE);
CData_Reset(BASEINST(idX),TRUE);
nFS = UD_FS(_this,nU);
nXS = UD_XS(_this,nU);
nFT = UD_FT(_this,nU);
nXT = UD_XT(_this,nU);
/* Export transposed ergodic incidence matrix */
IF_NOK(CData_AddNcomps(idP,DLP_TYPE(FST_WTYPE),UD_XS(_this,nU)+1)) break;
IF_NOK(CData_Allocate (idP,UD_XS(_this,nU)+1) ) break;
IF_NOK(CData_AddNcomps(idB,DLP_TYPE(FST_WTYPE),1 )) break;
IF_NOK(CData_Allocate (idB,UD_XS(_this,nU)+1) ) break;
/* Fill transposed incidence matrix
(summing up probabilities of parallel transitions) */
for (nT=nFT; nT<nFT+nXT; nT++)
*(FST_WTYPE*)CData_XAddr(idP,TD_TER(_this,nT),TD_INI(_this,nT)) +=
*(FST_WTYPE*)CData_XAddr(AS(CData,_this->td),nT,nIcW);
for (nS=0; nS<nXS; nS++)
{
if ((SD_FLG(_this,nS+nFS)&0x01)==0x01) /* Connect final states with start state */
{
for (nS2=1, nPSum=0.; nS2<nXS; nS2++)
nPSum += *(FST_WTYPE*)CData_XAddr(idP,nS2,nS);
*(FST_WTYPE*)CData_XAddr(idP,0,nS) = 1.-nPSum;
}
*(FST_WTYPE*)CData_XAddr(idP,nS,nS)-=1.; /* Subtract eigenvalue 1 from main diagonal */
*(FST_WTYPE*)CData_XAddr(idP,nXS,nS)=1.; /* Additional equation implementing constraint sum(P_state)=1 */
*(FST_WTYPE*)CData_XAddr(idP,nS,nXS)=1.; /* Additional variable making incidence matrix quadratic */
}
/* Fill constant vector */
CData_Fill(idB,CMPLX(1.),CMPLX(0.));
/* Calculate eigenvector of length 1 and eigenvalue 1
--> stationary state probabilities */
CMatrix_Op(idI,idP,T_INSTANCE,NULL,T_IGNORE,OP_INVT);
CMatrix_Op(idX,idB,T_INSTANCE,idI,T_INSTANCE,OP_MULT);
/* Fill in state reference counters */
if (nSeed>0.) nSeed /= CData_Dfetch(idX,0,0); else nSeed = 1.;
for (nS=0; nS<nXS; nS++)
CData_Dstore(AS(CData,_this->sd),nSeed*CData_Dfetch(idX,nS,0),nS+nFS,nIcRcs);
/* Calculate stationary transition probabilities */
for (nT=nFT; nT<nFT+nXT; nT++)
CData_Dstore
(
AS(CData,_this->td),
CData_Dfetch(AS(CData,_this->sd),TD_INI(_this,nT)+nFS,nIcRcs) *
CData_Dfetch(AS(CData,_this->td),nT,nIcW),
nT,nIcRct
);
/* Clean up */
IDESTROY(idP);
IDESTROY(idB);
IDESTROY(idI);
IDESTROY(idX);
/* Stop in single unit mode */
if (nUnit>=0) break;
}
return O_K;
#endif /* #ifdef __UNENTANGLE_FST */
}
