/////////////////////////////////////////////////////////////////////////////////////
//
// ModEx - generates excitation from pitch file
//
// CData *gain -> gains of excitation per frame
// CData *idPm -> both components must be type long
// CData *idExcite -> type FBA_FLOAT
//
INT16 CGEN_PUBLIC CFBAproc::ModEx(CData *idPm, CData *idExcite) {
// Error handling
if (idPm == NULL) return IERROR(this,ERR_NULLINST,0,0,0);
if (idPm -> IsEmpty() == TRUE) return IERROR(idPm,DATA_EMPTY,idPm->m_lpInstanceName,0,0);
if (idExcite == NULL) return IERROR(this,ERR_NULLINST,idExcite->m_lpInstanceName,0,0);
DLPASSERT(idPm->GetNComps()>1);
FLOAT64* exc = NULL;
INT32 n_exc = 0;
switch(m_lpsExcType[0]) {
case 'P':
if(dlm_pm2exc((INT16*)idPm->XAddr(0,0),(INT32)idPm->GetNRecs(),&exc,&n_exc,m_nSrate, (BOOL)TRUE,DLM_PITCH_PULSE ) != O_K) return NOT_EXEC;
break;
case 'G':
if(dlm_pm2exc((INT16*)idPm->XAddr(0,0),(INT32)idPm->GetNRecs(),&exc,&n_exc,m_nSrate, (BOOL)TRUE,DLM_PITCH_GLOTT ) != O_K) return NOT_EXEC;
break;
case 'R':
if(dlm_pm2exc((INT16*)idPm->XAddr(0,0),(INT32)idPm->GetNRecs(),&exc,&n_exc,m_nSrate, (BOOL)TRUE,DLM_PITCH_RANDPHASE) != O_K) return NOT_EXEC;
break;
case 'V':
if(dlm_pm2exc((INT16*)idPm->XAddr(0,0),(INT32)idPm->GetNRecs(),&exc,&n_exc,m_nSrate, (BOOL)TRUE,DLM_PITCH_VOICED ) != O_K) return NOT_EXEC;
break;
case 'U':
if(dlm_pm2exc((INT16*)idPm->XAddr(0,0),(INT32)idPm->GetNRecs(),&exc,&n_exc,m_nSrate, (BOOL)TRUE,DLM_PITCH_UNVOICED ) != O_K) return NOT_EXEC;
break;
case 'C':
if(m_idExc == NULL) return IERROR(this,ERR_BADPTR,NULL,"of CFBAproc->m_lpExc","(FBAproc.exc)");
for(INT32 i_pm=0; i_pm < idPm->GetNRecs(); i_pm++) n_exc += (INT16)idPm->Dfetch(i_pm,0);
if(CData_GetNRecs(m_idExc) < n_exc) return IERROR(this,FBA_BADEXCLEN,0,0,0);
exc = (FLOAT64*)dlp_malloc(n_exc*sizeof(FLOAT64));
dlp_memmove(exc,m_idExc->XAddr(0,0),n_exc*sizeof(FLOAT64));
break;
default:
return IERROR(this,FBA_BADARG,m_lpsExcType,"exc_type","P, G, R, V, U or C");
}
idExcite->Reset(TRUE);
idExcite->AddComp("exc", T_DOUBLE);
idExcite->Allocate(n_exc);
dlp_memmove(idExcite->XAddr(0,0), exc, n_exc*sizeof(FLOAT64));
dlp_free(exc);
return O_K;
}
/**
* 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;
}
}
/**
* <p>Calculates roots of a polynomial.</p>
*
* @param a
* Pointer to polynomial coefficients.
* @param m
* Number of polynomial coefficients stored in <CODE>a</CODE>.
* @param rtr
* Resulting real roots.
* @param rti
* Resulting imaginary roots.
* @return <code>O_K</code> if successful, a (negative) error code otherwise
*/
INT16 dlm_roots(FLOAT64* A, COMPLEX64* Z, INT16 nA) {
INT16 j, k;
integer m = nA;
integer ilo;
integer ihi;
integer info;
integer c__1 = 1;
integer lwork = 0;
char job1[1] = { 'S' };
char job2[1] = { 'E' };
char compz[1] = { 'N' };
#ifdef __MAX_TYPE_32BIT
int sgebal_(char*,integer*,real*,integer*,integer*,integer*,real*,integer*);
int shseqr_(char*,char*,integer*,integer*,integer*,real*,integer*,real*,real*,real*,integer*,real*,integer*,integer*);
#else
int dgebal_(char*,integer*,doublereal*,integer*,integer*,integer*,doublereal*,integer*);
int dhseqr_(char*,char*,integer*,integer*,integer*,doublereal*,integer*,doublereal*,doublereal*,doublereal*,integer*,doublereal*,integer*,integer*);
#endif
#define _H(i,j) *(hess+(j)+(i)*m)
if ((!A) || (!Z)) return NOT_EXEC;
k = 0;
while ((k < m) && (*(A + k) == 0.0)) {
k++;
A++;
}
m -= k;
m--;
if (m <= 0) return NOT_EXEC;
#ifdef __MAX_TYPE_32BIT
real* hess = (real*) dlp_malloc((4*m+m*m)*sizeof(real));
if (!hess) return ERR_MEM;
real* scale = hess + m * m;
real* wr = scale + m;
real* wi = wr + m;
real* work = wi + m;
#else
doublereal* hess=(doublereal*)dlp_malloc((4*m+m*m)*sizeof(doublereal));
if(!hess) return ERR_MEM;
doublereal* scale = hess + m*m;
doublereal* wr = scale + m;
doublereal* wi = wr + m;
doublereal* work = wi + m;
#endif
lwork = m;
for (k = 0; k < m; k++) {
_H(m-1,k) = -A[k + 1] / A[0];
for (j = 0; j < m - 1; j++)
_H(j,k) = ((j == (k - 1)) && (k > 0)) ? 1.0 : 0.0;
}
#ifdef __MAX_TYPE_32BIT
sgebal_(job1, &m, hess, &m, &ilo, &ihi, scale, &info);
shseqr_(job2, compz, &m, &ilo, &ihi, hess, &m, wr, wi, NULL, &c__1, work, &lwork, &info);
#else
dgebal_(job1, &m, hess, &m, &ilo, &ihi, scale, &info);
dhseqr_(job2, compz, &m, &ilo, &ihi, hess, &m, wr, wi, NULL, &c__1, work, &lwork, &info);
#endif
dlp_free(hess);
for (j = 0; j < m; j++) {
Z[j].x = wr[j];
Z[j].y = wi[j];
}
return (info == 0) ? O_K : NOT_EXEC;
#undef _H
}
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 */
}
INT16 CGEN_VPROTECTED CFBAproc::SynthesizeUsingInto(data *idFea, data *idInto, data *idSyn) {
INT32 nSamplingPoints = idInto->GetNRecs();
INT32 iSamplingPoints1 = 0;
INT32 iSamples = 0;
INT32 iSamplesOld = 0;
INT32 nSamples = 0;
INT32 nSamplesOfLastUnits = 0;
INT32 nSampleOfLastF0SamplingPoint = 0;
INT32 nSampleOfNextF0SamplingPoint = 0;
INT32 nPer = 0;
INT32 iFrames = 0;
INT32 iFramesOld = 0;
INT32 nFrames = idFea->GetNRecs();
INT32 iLab = 0;
INT32 nLab = 0;
INT32 iFea = 0;
INT32 nCompVuv = idFea->FindComp("v/uv");
INT32 nFea = idFea->GetNNumericComps() - (nCompVuv >= 0 ? 1 : 0);
const char* nextF0Pho = NULL;
FLOAT64 lastF0Val = 1.0;
FLOAT64 currF0Val = 1.0;
FLOAT64 nextF0Val = 1.0;
FLOAT64 nextF0Pos = 0.0;
FLOAT64 lastI0Val = 1.0;
FLOAT64 currI0Val = 1.0;
FLOAT64 nextI0Val = 1.0;
FLOAT64* exc = NULL;
FLOAT64* fea = NULL;
FLOAT64* feaBefore = NULL;
FLOAT64* feaUsed = NULL;
FLOAT64* feaUsedBefore = NULL;
BOOL isVoiceless = FALSE;
BOOL isSmoothable = FALSE;
BOOL isSmoothableBefore = FALSE;
SLAB* sIntoLab = NULL;
SLAB* sFeaLab = NULL;
if(nSamplingPoints <= 0) {
return O_K;
}
if(SynthesizeUsingIntoGetFeaIntoLab(idFea, idInto, &sFeaLab, &sIntoLab, &nSamples, &nLab) != O_K) {
if(sFeaLab != NULL) dlp_free(sFeaLab);
if(sIntoLab != NULL) dlp_free(sIntoLab);
return NOT_EXEC;
}
exc = (FLOAT64*)dlp_malloc(nSamples * sizeof(FLOAT64));
fea = (FLOAT64*)dlp_malloc(nFea * sizeof(FLOAT64));
feaBefore = (FLOAT64*)dlp_malloc(nFea * sizeof(FLOAT64));
idSyn->Reset(TRUE);
idSyn->AddComp("syn", T_DOUBLE);
idSyn->Allocate(nSamples);
iFrames = 0;
iLab = 0;
iSamplingPoints1 = 0;
iSamples = 0;
iSamplesOld = 0;
iFramesOld = 0;
nSamplesOfLastUnits = 0;
while(iSamples < nSamples) {
if(iSamples >= nSampleOfNextF0SamplingPoint) {
lastF0Val = nextF0Val;
lastI0Val = nextI0Val;
nSampleOfLastF0SamplingPoint = nSampleOfNextF0SamplingPoint;
while(iSamples >= nSampleOfNextF0SamplingPoint) {
for(; iSamplingPoints1 < nSamplingPoints; iSamplingPoints1++) {
nextF0Pho = idInto->Sfetch(iSamplingPoints1, 2);
nextF0Val = idInto->Dfetch(iSamplingPoints1, 3);
nextI0Val = idInto->Dfetch(iSamplingPoints1, 6);
nextF0Pos = idInto->Dfetch(iSamplingPoints1, 4);
if(iSamplingPoints1 && dlp_strcmp(idInto->Sfetch(iSamplingPoints1-1, 0), idInto->Sfetch(iSamplingPoints1, 0))) {
nSamplesOfLastUnits += (INT32)idInto->Dfetch(iSamplingPoints1-1, 1);
}
if((nextF0Val > 0.0) && (nextF0Pos >= 0.0) && (nextF0Pho != NULL) && (dlp_strlen(nextF0Pho) > 0)) {
break;
} else {
if(this->m_nCheck > 0) {
dlp_message(__FILE__,__LINE__,"no next f0 value");
}
}
}
if(iSamplingPoints1 >= nSamplingPoints) {
nextF0Val = 1.0;
nextI0Val = 1.0;
nSampleOfNextF0SamplingPoint = nSamples;
} else {
nSampleOfNextF0SamplingPoint = (INT32)(((FLOAT64)nSamplesOfLastUnits + idInto->Dfetch(iSamplingPoints1, 1) * nextF0Pos) * (FLOAT64)m_nSrate / 1000.0 + 0.5);
iSamplingPoints1++;
}
}
}
currF0Val = lastF0Val + (nextF0Val - lastF0Val) * (iSamples - nSampleOfLastF0SamplingPoint) / (nSampleOfNextF0SamplingPoint+1 - nSampleOfLastF0SamplingPoint);
nPer = (INT32)((FLOAT64)m_nSrate / (currF0Val * (FLOAT64)m_nBaseF0) + 0.5);
if((iSamples+nPer) > nSamples) nPer = nSamples-iSamples;
currI0Val = lastI0Val + (nextI0Val - lastI0Val) * (iSamples - nSampleOfLastF0SamplingPoint) / (nSampleOfNextF0SamplingPoint+1 - nSampleOfLastF0SamplingPoint);
while((iLab < nLab) && (sIntoLab[iLab].pos < iSamples)) {
iSamplesOld = sIntoLab[iLab].pos;
iFramesOld = INT32((FLOAT64)sFeaLab[iLab].pos / (FLOAT64)m_nCrate + 0.5);
iLab++;
}
while((iFrames < nFrames) &&
(((FLOAT64)(((iFrames-iFramesOld+1L))*m_nCrate)/((iLab>0)?(FLOAT64)(sFeaLab[iLab].pos -sFeaLab[iLab-1].pos ):sFeaLab[iLab].pos )) <
((FLOAT64)(iSamples-iSamplesOld) /((iLab>0)?(FLOAT64)(sIntoLab[iLab].pos-sIntoLab[iLab-1].pos):sIntoLab[iLab].pos))))
iFrames++;
dlp_memmove(fea, (FLOAT64*)idFea->XAddr(iFrames, 0), nFea*sizeof(FLOAT64));
if(m_bSynEnhancement) {
FeaEnhancement(fea, nFea);
}
if(nCompVuv>=0) {
isVoiceless = (*(INT16*)idFea->XAddr(iFrames, nCompVuv) & 1) == 0;
isSmoothable = (*(INT16*)idFea->XAddr(iFrames, nCompVuv) & 2) == 0;
} else {
isVoiceless = IsFeaVoiceless(fea, nFea);
isSmoothable = 1;
}
if(feaUsed == NULL) {
feaUsed = (FLOAT64*)dlp_malloc(nFea*sizeof(FLOAT64));
dlp_memmove(feaUsed, fea, nFea*sizeof(FLOAT64));
}
if(m_bSynSmoothFea) {
if(feaUsedBefore == NULL) {
feaUsedBefore = (FLOAT64*)dlp_malloc(nFea*sizeof(FLOAT64));
dlp_memmove(feaUsedBefore, fea, nFea*sizeof(FLOAT64));
} else {
if(isSmoothableBefore && isSmoothable) {
for(iFea = 0; iFea < nFea; iFea++) {
feaUsed[iFea] = 0.29289322 * (feaBefore[iFea] + fea[iFea]) + 0.41421356 * feaUsedBefore[iFea];
}
} else if(isSmoothableBefore && !isSmoothable) {
for(iFea = 0; iFea < nFea; iFea++) {
feaUsed[iFea] = 0.75 * feaBefore[iFea] + 0.25 * fea[iFea];
}
} else if(!isSmoothableBefore && isSmoothable) {
for(iFea = 0; iFea < nFea; iFea++) {
feaUsed[iFea] = 0.25 * feaBefore[iFea] + 0.75 * fea[iFea];
}
} else {
dlp_memmove(feaUsed, fea, nFea*sizeof(FLOAT64));
}
}
isSmoothableBefore = isSmoothable;
dlp_memmove(feaUsedBefore, feaUsed, nFea*sizeof(FLOAT64));
} else {
dlp_memmove(feaUsed, fea, nFea*sizeof(FLOAT64));
}
dlp_memmove(feaBefore, fea, nFea*sizeof(FLOAT64));
FLOAT64 gain = ((m_nWnorm == 0 ) ? 1.0 : (FLOAT64)sqrt((double)nPer)) * exp(m_nBaseI0) * currI0Val;
switch(m_lpsExcType[0]) {
case 'P':
dlm_getExcPeriod(nPer, !isVoiceless, DLM_PITCH_PULSE, 1.0/gain, m_nSrate, exc+iSamples);
break;
case 'G':
dlm_getExcPeriod(nPer, !isVoiceless, DLM_PITCH_GLOTT, 1.0/gain, m_nSrate, exc+iSamples);
break;
case 'R':
dlm_getExcPeriod(nPer, !isVoiceless, DLM_PITCH_RANDPHASE, 1.0/gain, m_nSrate, exc+iSamples);
break;
case 'V':
dlm_getExcPeriod(nPer, !isVoiceless, DLM_PITCH_VOICED, 1.0/gain, m_nSrate, exc+iSamples);
break;
case 'U':
dlm_getExcPeriod(nPer, !isVoiceless, DLM_PITCH_UNVOICED, 1.0/gain, m_nSrate, exc+iSamples);
break;
default:
return IERROR(this,FBA_BADARG,m_lpsExcType,"exc_type","P, G, R, V or U");
}
if(this->m_nCheck > 0) {
dlp_message(__FILE__,__LINE__,"nPer=%5d, uv/v=%1d, s/ns=%ld, pos=%7.1f, F0=%4.2f/%4.2f/%4.2f, idFea (%3d) %5s, Fea (%3d): %5s (%3d), Into (%3d) %5s (%3d)", \
(int)nPer,
(int)!isVoiceless,
(int)isSmoothable,
(double)((FLOAT64)iSamples*1000.0/(FLOAT64)m_nSrate),
(double)lastF0Val,
(double)currF0Val,
(double)nextF0Val,
(int)iFrames,
idFea->Sfetch(iFrames, nFea),
(int)iLab, sFeaLab[iLab].phoneme,
(int)sFeaLab[iLab].pos,
(int)iLab, sIntoLab[iLab].phoneme,
(int)sIntoLab[iLab].pos);
}
if(SynthesizeFrame(feaUsed, nFea, &exc[iSamples], nPer, (FLOAT64*)idSyn->XAddr(iSamples, 0)) != O_K) return IERROR(this,FBA_SYNTHESISE, iFrames, 0,0);
iSamples += nPer;
}
dlp_free(exc);
dlp_free(sIntoLab);
dlp_free(sFeaLab);
dlp_free(fea);
dlp_free(feaBefore);
dlp_free(feaUsed);
if(m_bSynSmoothFea) {
dlp_free(feaUsedBefore);
}
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;
}
