/* * 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 */ }