/* AppendParm: append the src file to current Buffer pb. Return appended len */
HTime AppendParm(char *src)
{
int i;
char bf1[MAXSTRLEN];
char bf2[MAXSTRLEN];
short swidth[SMAX];
Boolean eSep;
ParmBuf b, cb;
Observation o;
BufferInfo info;
if((b = OpenBuffer(&iStack,src,0,srcFF,TRI_UNDEF,TRI_UNDEF))==NULL)
HError(1050,"AppendParm: Config parameters invalid");
GetBufferInfo(b,&info);
if(trace & T_KINDS ){
printf("Appending file %s format: %s [%s]->[%s]\n",src,
Format2Str(info.srcFF), ParmKind2Str(info.srcPK,bf1),
ParmKind2Str(info.tgtPK,bf2));
}
if (tgtSampRate != info.tgtSampRate)
HError(1032,"AppendParm: Input file %s has inconsistent sample rate",src);
if ( BaseParmKind(tgtPK) != BaseParmKind(info.tgtPK))
HError(1032,"AppendParm: Input file %s has inconsistent tgt format",src);
cb = (chopF)?ChopParm(b,st,en,info.tgtSampRate) : b;
ZeroStreamWidths(swidth0,swidth);
SetStreamWidths(info.tgtPK,info.tgtVecSize,swidth,&eSep);
o = MakeObservation(&iStack, swidth, info.tgtPK, saveAsVQ, eSep);
for (i=0; i < ObsInBuffer(cb); i++){
ReadAsTable(cb, i, &o);
AddToBuffer(pb, o);
}
CloseBuffer(cb);
return(i*info.tgtSampRate);
}
/* Initialise: set up global data storage */
void Initialise(char *datafn)
{
ParmBuf pbuf;
int s;
Boolean eSep;
CreateHeap(&iStack,"inBuf", MSTAK, 1, 0.5, 100000, LONG_MAX);
CreateHeap(&dStack,"seqStack", MSTAK, 1, 0.5, 100000, LONG_MAX);
CreateHeap(&cStack,"clustStack",MSTAK, 1, 0.5, 100000, LONG_MAX);
/* Peek at first data file to get observation format */
if((pbuf = OpenBuffer(&iStack, datafn, 0, UNDEFF, FALSE_dup, FALSE_dup))==NULL)
HError(2550,"Initialise: Config parameters invalid");
GetBufferInfo(pbuf, &info);
CloseBuffer(pbuf);
ResetHeap(&iStack);
/* set/validate stream widths */
if(swidth[0] > 0)
CheckStreamWidths(info);
else
ZeroStreamWidths(1,swidth);
/* Create an observation to hold the input parameters */
SetStreamWidths(info.tgtPK,info.tgtVecSize,swidth,&eSep);
obs = MakeObservation(&gstack,swidth,info.tgtPK,FALSE,eSep);
if (segLab != NULL)
segId = GetLabId(segLab,TRUE);
/* Create sequences to hold all data*/
for (s=1;s<=swidth[0];s++)
dSeq[s] = CreateSequence(&dStack,4096);
}
/* Accumulate stats from an utterance file */
SpkrAcc *AccGenUtt(char *SpkrPattern, char *UttFileName, SpkrAcc *sa)
{
char SpkrName[MAXSTRLEN];
ParmBuf pbuf;
BufferInfo info;
short swidth[SMAX];
Boolean eSep;
Vector tempV;
int i;
if (MaskMatch(SpkrPattern,SpkrName,UttFileName)==TRUE){
/* open buffer and construct observation */
pbuf = OpenBuffer(&iStack,UttFileName,0,dff,FALSE_dup,FALSE_dup);
GetBufferInfo(pbuf,&info);
if ((info.tgtPK & HASZEROM) && strchr(oflags,'m')) {
HError(-2021,"HCompV: AccGenUtt: qualifier _Z not appropriate when calculating means!\n");
}
/* treat as single stream system though a bit weird */
ZeroStreamWidths(1,swidth);
SetStreamWidths(info.tgtPK,info.tgtVecSize,swidth,&eSep);
obs = MakeObservation(&gstack,swidth,info.tgtPK,FALSE,eSep);
if (info.tgtVecSize != vSize){
vSize = info.tgtVecSize;
/* if needed init a SpkrAcc */
sa = InitSpkrAcc();
fprintf(stdout,"Target observation vector size set to %d ......\n",info.tgtVecSize);
fflush(stdout);
}
ParmKind2Str(info.tgtPK,TargetPKStr);
/* accumulate stats for current utterance file */
StartBuffer(pbuf);
while (BufferStatus(pbuf) != PB_CLEARED)
{
/* copy current observation and set vector ptr to first stream */
ReadAsBuffer(pbuf,&obs);
tempV = obs.fv[1];
for (i=1;i<=vSize;i++){
sa->meanSum[i] += tempV[i];
sa->squareSum[i] += tempV[i]*tempV[i];
}
sa->NumFrame += 1;
}
CloseBuffer(pbuf);
strcpy(sa->SpkrName,SpkrName);
if (trace&T_CMV){
fprintf(stdout,"Utterance %s accumulate generated for speaker %s\n",UttFileName,sa->SpkrName);
fflush(stdout);
}
ResetHeap(&iStack);
return sa;
}
else {
HError(2039,"HCompV: AccGenUtt: speaker pattern matching failure on file: %s\n",UttFileName);
return NULL;
}
}
/* InitSegStore : Initialise segStore for particular observation */
void InitSegStore(BufferInfo *info)
{
Observation obs;
Boolean eSep;
SetStreamWidths(info->tgtPK,info->tgtVecSize,hset.swidth,&eSep);
obs = MakeObservation(&gstack,hset.swidth,info->tgtPK,
hset.hsKind==DISCRETEHS,eSep);
segStore = CreateSegStore(&segmentStack,obs,10);
firstTime = FALSE;
}
/* DoGeneration: Generate parameter sequences from HMMs */
void DoGeneration(char *labfn)
{
char labFn[MAXFNAMELEN], buf[MAXSTRLEN];
int t;
Boolean eSep;
Transcription *tr;
if (trace & T_TOP) {
printf(" Generating Label %s\n", NameOf(labfn, buf));
fflush(stdout);
}
/* load a given input label file */
ResetHeap(&utt->transStack);
MakeFN(labfn, labDir, labExt, labFn);
tr = LOpen(&genStack, labFn, lff);
/* compose a sentence HMM corresponding to the input label */
InitialiseGenInfo(genInfo, tr, FALSE);
/* set utterance informations for forward-backward algorithm */
SetStreamWidths(hmset.pkind, hmset.vecSize, hmset.swidth, &eSep);
utt->tr = tr;
utt->Q = genInfo->labseqlen;
utt->T = genInfo->tframe;
utt->twoDataFiles = FALSE;
utt->o = (Observation *) New(&gstack, utt->T * sizeof(Observation));
utt->o--;
for (t = 1; t <= utt->T; t++)
utt->o[t] = MakeObservation(&gstack, hmset.swidth, hmset.pkind, FALSE, eSep);
/* parameter generation */
ParamGen(genInfo, utt, fbInfo, type);
/* output state durations and generated parameter sequences */
if (!stateAlign)
WriteStateDurations(labfn, genInfo);
WriteParms(labfn, genInfo);
/* free memory */
Dispose(&gstack, ++utt->o);
ResetGenInfo(genInfo);
/* increment total number of generated frames */
totalT += utt->T;
totalPr += utt->pr;
return;
}
/* ChopParm: return parm chopped to st and end. end = 0 means all */
ParmBuf ChopParm(ParmBuf b, HTime start, HTime end, HTime sampRate)
{
int stObs, endObs, nObs, i;
HTime length;
short swidth[SMAX];
Boolean eSep;
ParmBuf cb;
Observation o;
BufferInfo info;
length = ObsInBuffer(b) * sampRate;
ClampStEn(length,&start,&end);
if(start >= length)
HError(1030,"ChopParm: Src file too short to get data from %.0f",start);
if(trace & T_SEGMENT)
printf("ChopParm: Extracting segment %.0f to %.0f\n",start,end);
stObs = (int) (start/sampRate);
endObs = (int) (end/sampRate);
nObs = endObs -stObs;
if(nObs <= 0)
HError(1030,"ChopParm: Truncation options result in zero-length file");
GetBufferInfo(b,&info);
ZeroStreamWidths(swidth0,swidth);
SetStreamWidths(tgtPK,info.tgtVecSize,swidth,&eSep);
o = MakeObservation(&cStack, swidth, info.tgtPK, saveAsVQ, eSep);
if (saveAsVQ){
if (info.tgtPK&HASNULLE){
info.tgtPK=DISCRETE+HASNULLE;
}else{
info.tgtPK=DISCRETE;
}
}
cb = EmptyBuffer(&cStack, nObs, o, info);
for (i=stObs; i < endObs; i++){
ReadAsTable(b, i, &o);
AddToBuffer(cb, o);
}
CloseBuffer(b);
if(chopF && labF) ChopLabs(tr,start,end);
return(cb);
}
/* OpenParmFile: open source parm file and return length */
HTime OpenParmFile(char *src)
{
int i;
ParmBuf b, cb;
short swidth[SMAX];
Boolean eSep;
Observation o;
BufferInfo info;
if((b = OpenBuffer(&iStack,src,0,srcFF,TRI_UNDEF,TRI_UNDEF))==NULL)
HError(1050,"OpenParmFile: Config parameters invalid");
GetBufferInfo(b,&info);
srcSampRate = info.srcSampRate;
tgtSampRate = info.tgtSampRate;
srcPK = info.srcPK; tgtPK = info.tgtPK;
cb = chopF?ChopParm(b,st,en,info.tgtSampRate):b;
ZeroStreamWidths(swidth0,swidth);
SetStreamWidths(info.tgtPK,info.tgtVecSize,swidth,&eSep);
o = MakeObservation(&oStack, swidth, info.tgtPK, saveAsVQ, eSep);
if (saveAsVQ){
if (info.tgtPK&HASNULLE){
info.tgtPK=DISCRETE+HASNULLE;
}else{
info.tgtPK=DISCRETE;
}
}
pb = EmptyBuffer(&oStack, ObsInBuffer(cb), o, info);
for(i=0; i < ObsInBuffer(cb); i++){
ReadAsTable(cb, i, &o);
AddToBuffer(pb, o);
}
CloseBuffer(cb);
if( info.nSamples > 0 )
return(info.nSamples*srcSampRate);
else
return(ObsInBuffer(pb)*info.tgtSampRate);
}
barwidth = itemWidth*(nItems+1);
}
/* PrintHeading: print the info in given HeadInfo record */
void PrintHeading(HeadInfo h)
{
char buf[MAXSTRLEN];
if (h.isSource){
if (h.isAudio)
strcpy(buf,"Source: Direct Audio");
else
sprintf(buf,"Source: %s", h.name);
}else
strcpy(buf,"Target");
PrBar(buf);
printf(" Sample Bytes: %-7d", h.sampSize);
if (barwidth < 60 ) printf("\n");
printf(" Sample Kind: %s\n", ParmKind2Str(h.kind,buf));
printf(" Num Comps: %-7d", h.numComps);
if (barwidth < 60 ) printf("\n");
printf(" Sample Period: %.1f us\n", h.period/10.0);
if (!h.isAudio) {
printf(" Num Samples: %-7ld", h.nSamples);
if (barwidth < 60 ) printf("\n");
printf(" File Format: %s\n", Format2Str(h.fmt));
}
}
/* PrintWaveLine: print line of waveform samples */
void PrintWaveLine(short *data, int nItems, long idx)
{
int i;
if (!rawOut) printf("%5ld: ",idx);
for (i=0; i<nItems; i++) printf("%7d",*data++);
printf("\n");
}
/* PrintRawVec: print vector components */
void PrintRawVec(Vector v)
{
int i;
for (i=1; i<=VectorSize(v); i++) printf("%e ",v[i]);
printf("\n");
/* Initialise: load HMMs and create accumulators */
static void Initialise(void)
{
int s,V;
Boolean eSep;
char base[MAXSTRLEN];
char path[MAXSTRLEN];
char ext[MAXSTRLEN];
/* Load HMM defs */
if(MakeOneHMM(&hset,BaseOf(hmmfn,base))<SUCCESS)
HError(2028,"Initialise: MakeOneHMM failed");
if(LoadHMMSet(&hset,PathOf(hmmfn,path),ExtnOf(hmmfn,ext))<SUCCESS)
HError(2028,"Initialise: LoadHMMSet failed");
SetParmHMMSet(&hset);
if (hset.hsKind==DISCRETEHS || hset.hsKind==TIEDHS)
HError(2030,"Initialise: HCompV only uses continuous models");
/* Create a heap to store the input data */
/*CreateHeap(&iStack,"InBuf", MSTAK, 1, 0.5, 100000, LONG_MAX);*/
/* Get a pointer to the physical HMM */
hmmId = GetLabId(base,FALSE);
macroLink = FindMacroName(&hset,'h',hmmId);
if (macroLink==NULL)
HError(2020,"Initialise: cannot find hmm %s in hset",hmmfn);
hmmLink = (HLink)macroLink->structure;
/* Find out for which streams full covariance is needed */
CheckVarianceKind( );
/* Create accumulators for the mean and variance */
for (s=1;s<=hset.swidth[0]; s++){
V = hset.swidth[s];
accs[s].meanSum=CreateVector(&gstack,V);
ZeroVector(accs[s].meanSum);
if (fullcNeeded[s]) {
accs[s].squareSum.inv=CreateSTriMat(&gstack,V);
accs[s].fixed.inv=CreateSTriMat(&gstack,V);
ZeroTriMat(accs[s].squareSum.inv);
}
else {
accs[s].squareSum.var=CreateSVector(&gstack,V);
accs[s].fixed.var=CreateSVector(&gstack,V);
ZeroVector(accs[s].squareSum.var);
}
}
/* Create an object to hold the input parameters */
SetStreamWidths(hset.pkind,hset.vecSize,hset.swidth,&eSep);
obs=MakeObservation(&gstack,hset.swidth,hset.pkind,FALSE,eSep);
if(segLab != NULL) {
segId = GetLabId(segLab,TRUE);
}
if (trace&T_TOP) {
printf("Calculating Fixed Variance\n");
printf(" HMM Prototype: %s\n",hmmfn);
printf(" Segment Label: %s\n",(segLab==NULL)?"None":segLab);
printf(" Num Streams : %d\n",hset.swidth[0]);
printf(" UpdatingMeans: %s\n",(meanUpdate)?"Yes":"No");
printf(" Target Direct: %s\n",(outDir==NULL)?"Current":outDir);
}
}
/* Initialise: set up global data structures */
void Initialise(void)
{
Boolean eSep;
int s;
/* Load hmms, convert to inverse DiagC */
if(MakeHMMSet(&hset,hmmListFn)<SUCCESS)
HError(3228,"Initialise: MakeHMMSet failed");
if(LoadHMMSet(&hset,hmmDir,hmmExt)<SUCCESS)
HError(3228,"Initialise: LoadHMMSet failed");
ConvDiagC(&hset,TRUE);
/* Create observation and storage for input buffer */
SetStreamWidths(hset.pkind,hset.vecSize,hset.swidth,&eSep);
obs=MakeObservation(&gstack,hset.swidth,hset.pkind,
hset.hsKind==DISCRETEHS,eSep);
/* sort out masks just in case using adaptation */
if (xfInfo.inSpkrPat == NULL) xfInfo.inSpkrPat = xfInfo.outSpkrPat;
if (xfInfo.paSpkrPat == NULL) xfInfo.paSpkrPat = xfInfo.outSpkrPat;
if (xfInfo.useOutXForm || (update>0)) {
CreateHeap(®Heap, "regClassStore", MSTAK, 1, 0.5, 1000, 8000 );
/* This initialises things - temporary hack - THINK!! */
CreateAdaptXForm(&hset, "tmp");
/* initialise structures for the f-b frame-state alignment pass */
utt = (UttInfo *) New(®Heap, sizeof(UttInfo));
fbInfo = (FBInfo *) New(®Heap, sizeof(FBInfo));
/* initialise a recogniser for frame/state alignment purposes */
alignpsi=InitPSetInfo(&hset);
alignvri=InitVRecInfo(alignpsi,1,TRUE,FALSE);
SetPruningLevels(alignvri,0,genBeam,-LZERO,0.0,tmBeam);
InitUttInfo(utt, FALSE);
InitialiseForBack(fbInfo, ®Heap, &hset,
(UPDSet) (UPXFORM), genBeam*2.0, genBeam*2.0,
genBeam*4.0+1.0, 10.0);
utt->twoDataFiles = FALSE;
utt->S = hset.swidth[0];
AttachPreComps(&hset,hset.hmem);
}
CreateHeap(&bufHeap,"Input Buffer heap",MSTAK,1,0.0,50000,50000);
CreateHeap(&repHeap,"Replay Buffer heap",MSTAK,1,0.0,50000,50000);
maxM = MaxMixInSet(&hset);
for (s=1; s<=hset.swidth[0]; s++)
maxMixInS[s] = MaxMixInSetS(&hset, s);
if (trace&T_TOP) {
printf("Read %d physical / %d logical HMMs\n",
hset.numPhyHMM,hset.numLogHMM); fflush(stdout);
}
/* Initialise recogniser */
if (nToks>1) nBeam=genBeam;
psi=InitPSetInfo(&hset);
vri=InitVRecInfo(psi,nToks,models,states);
/* Read dictionary and create storage for lattice */
InitVocab(&vocab);
if(ReadDict(dictFn,&vocab)<SUCCESS)
HError(3213, "Main: ReadDict failed");
CreateHeap(&ansHeap,"Lattice heap",MSTAK,1,0.0,4000,4000);
if (trace & T_MEM){
printf("Memory State After Initialisation\n");
PrintAllHeapStats();
}
}