/**
* Export midi notes of data instance into midifile, needs external program midiconvert
*
* @param lpsFilename Name of file to export
* @param iSst Pointer to instance to export
* @param lpsFiletype Type of file to export
* @return <code>O_K</code> if successful, a (negative) error code otherwise
*/
INT16 CGEN_PROTECTED CDlpFile_Midi_ExportMidi
(
CDlpFile* _this,
const char* lpsFilename,
CDlpObject* iSrc,
const char* lpsFiletype
)
{
char lpsTempFile[L_PATH];
char lpsCmdline [3*L_PATH] = "";
INT16 nErr =O_K;
strcpy(lpsTempFile,dlp_tempnam(NULL,"dlabpro_midi_export"));
sprintf(lpsCmdline,"midiconvert %s %s", lpsTempFile, lpsFilename);
CData *idSrc = AS(CData,iSrc);
CData_InsertRecs(idSrc, 0, 1, 1);
CData_Dstore(idSrc, CData_GetDescr(idSrc,DESCR0),0,5);
IF_NOK(CDlpFile_ExportAsciiFromData(_this,lpsTempFile,iSrc,"csv"))
nErr = IERROR(iSrc,FIL_EXPORT,lpsTempFile,"csv",0);
CData_DeleteRecs(idSrc,0,1);
if (system(lpsCmdline)!=0) { nErr=IERROR(_this,FIL_EXEC,lpsCmdline,0,0); }
if (remove(lpsTempFile)==-1) nErr=IERROR(_this,FIL_REMOVE,"temporary ",lpsTempFile,0);
/* Clean up */
return nErr;
}
/* DP decoder search function
*
* This function decodes using the time variant weights.
*
* @param glob Pointer to the global memory structure
* @param w Pointer to the time variant weight array
* @return <code>NULL</code> if successfull, the error string otherwise
*/
const char *fsts_sdp_isearch(struct fsts_glob *glob,struct fsts_w *w){
CFst *itDst=(CFst*)glob->algo;
if(glob->cfg.sdp.prn){
itDst->m_nPrnConst=glob->cfg.sdp.prn;
itDst->m_bPrune=TRUE;
}
if(glob->cfg.sdp.epsremove) itDst->m_bEpsremove=TRUE;
if(glob->cfg.sdp.fwd) itDst->m_bFwd=TRUE;
if(CFst_Sdp((CFst*)glob->algo,glob->src.itSrc,0,w->idW)!=O_K) return FSTSERR("sdp failed");
glob->mem =
UD_XS(glob->src.itSrc,0)*2*sizeof(FST_LB_TYPE) + /* lpLBrd, lpLBwr */
sizeof(FST_BT_TYPE) + CData_GetDescr(AS(CData,((CFst*)glob->algo)->ud),DESCR4)*sizeof(BYTE*) /* BT */;
return NULL;
}
INT16 CGEN_PRIVATE CProsody::EnergyContour(data *dSignal, data *dEnergy)
{
/* Initialization */
INT32 i = 0;
INT32 j = 0;
INT32 nSrate = 0; // Sample Rate
INT32 nSamples = 0; // Number of samples in WAV-signal (number of records in data instance)
INT32 nWindowShift = 0; // Shift of Windows (samples)
INT32 nWindowLength = 0; // Length of Window (samples)
INT32 nShiftNumber = 0; // Number of Shifts in the signal
INT32 nWindowNumber = 0; // Number of windows
FLOAT64 nAuxEner = 0; // Auxiliary variable to calculate the energy for one window
FLOAT64 *samples = NULL; // WAV Signal in double
FLOAT64 *dEnergyContour = NULL; // Short Time Energy Contour
/* Validation of data instance dEnergy */
if (!dEnergy || !dEnergy->IsEmpty()) // If dEnergy not exist or empty then return false
return NOT_EXEC; // NOT_EXEC = -1 (Generic error)
/* Definition of data instance dEnergy */
// One column is the values of energy contour
dEnergy->AddNcomps(T_DOUBLE, 1);
dEnergy->SetCname(0, "nEnergy");
/* Compute Sample Rate (SR) */
//nSrate = m_nSrate;
//nSrate = (INT32)(1000.0/CData_GetDescr(dSignal,RINC));
//# "\n Distance between two Samples = ${idSig.rinc} [msec] " -echo;
//# 1000 idSig.rinc / nSrate =; # Compute Sample Rate (SR)
nSrate = (INT32)((1000.0/CData_GetDescr(dSignal,RINC)) + 0.5); /* +0.5 forces cast to round up or down */
//fprintf(stdout,"Sample Rate: %d Hz\n\n",nSrate);
/* Number of samples in WAV-signal */
nSamples = dSignal->GetNRecs(); // GetNRecs returns the number of valid records in the data instance
//fprintf(stdout,"Number of samples in WAV-signal: %i\n\n",nSamples);
/* Copies data from memory area to another memory area */
samples = (FLOAT64*)dlp_calloc(nSamples, sizeof(FLOAT64)); // dlp_calloc(NUM,SIZE) Allocates zero-initialize memory
dlp_memmove(samples, dSignal->XAddr(0,0), nSamples * sizeof(FLOAT64));
/*
fprintf(stdout,"\n The samples of speech signal are: \n"); // show data
for(i=0; i<nSamples; i++)
fprintf(stdout,"Signal Sample %i = %f\n",i,samples[i]);
*/
/* Calculate the Window-Length and the Window-Shift */
nWindowShift = nSrate / 100; // Shift = 10 msec = 16000 / 100 = 160 samples
nWindowLength = nWindowShift * 3; // Window Length = 30 msec = Window Shift * 3
nShiftNumber = nSamples / nWindowShift; // Number of Shifts in the whole signal
nWindowNumber = nShiftNumber - 2; // Number of Windows
if (nWindowNumber < 1) // There is no window (signal is too short)
{
nWindowNumber = 1; // Set number of windows to 1
nWindowLength = nSamples;
}
dEnergyContour = (FLOAT64*)dlp_calloc(nWindowNumber, sizeof(FLOAT64));
/* Fensterung des Signals und Berechnung der Energy f�r jedes Fensters */
for (i=0; i<nWindowNumber; i++)
{
nAuxEner = 0;
for (j=0; j<nWindowLength; j++)
{
nAuxEner = nAuxEner + samples[i*nWindowShift+j]*samples[i*nWindowShift+j];
}
dEnergyContour[i] = nAuxEner;
}
/* Write Energy values in struct */
STEnergy_CONTOUR *Energy_contour = NULL; // (Energy_contour) is an object of struct (STEnergy_CONTOUR)
Energy_contour = (STEnergy_CONTOUR*)dlp_calloc(nWindowNumber, sizeof(STEnergy_CONTOUR)); // Allocates zero-initialize memory
for(i = 0; i < nWindowNumber; i++)
{
(Energy_contour + i)->nEnergyValue = dEnergyContour[i];
//fprintf( stdout,"nEnergyValue %i = %f\n",i,dEnergyContour[i] );
}
/* Copy Energy values from (struct Energy_contour) to output data object (dEnergy) */
dEnergy->AddRecs(nWindowNumber, 1); // AddRecs: Appends (n) records to the end of the table (data object)
for( i = 0; i < nWindowNumber; i++ )
{
dEnergy->Dstore((FLOAT64)(Energy_contour + i)->nEnergyValue, i, 0);
}
/*
FLOAT64 nAuxCopy = 0;
for (i = 0; i < nWindowNumber; i++)
{
nAuxCopy = (FLOAT64)CData_Dfetch(dEnergy,i,0);
fprintf(stdout,"F0 value %i = %f\n",i,nAuxCopy);
}
*/
dlp_free(samples);
dlp_free(dEnergyContour);
dlp_free(Energy_contour);
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 */
}
