?? vadout.c
字號:
/* wrapped around circular buffer (tailIdx < headIdx) */
k1 = pOutBuf->headIdx;
numSamps1 = (pOutBuf->len - pOutBuf->headIdx);
if (ACTIVE == *pPrevDecisionState)
{
cSampsWritten = fwrite(&(pOutBuf->pBuf[k1]), sizeof(Ipp16s), numSamps1, pOutputPCMFile);
}
k2 = 0;
numSamps2 = pOutBuf->tailIdx + 1;
if (ACTIVE == *pPrevDecisionState)
{
cSampsWritten = fwrite(&(pOutBuf->pBuf[k2]), sizeof(Ipp16s), numSamps2, pOutputPCMFile);
}
}
else
{
/* circular buffer not wrapped (headIdx < tailIdx) */
k1 = pOutBuf->headIdx;
numSamps1 = (pOutBuf->tailIdx - pOutBuf->headIdx + 1);
if (ACTIVE == *pPrevDecisionState)
{
cSampsWritten = fwrite(&(pOutBuf->pBuf[k1]), sizeof(Ipp16s), numSamps1, pOutputPCMFile);
}
}
/* reset circular buffer pointers */
pOutBuf->headIdx=0;
pOutBuf->tailIdx=-1;
break;
default:
break;
}
}
/********************************************************************************/
#else /* no CHOP_SILENCE - zero the silence data */
/********************************************************************************/
void OUT_ConditionalFlushBuffer(
CircBufStruct16s* pOutBuf,
int decisionSampNum,
VADDecisionState curDecisionState,
VADDecisionState* pPrevDecisionState,
int cLookAheadSamps,
FILE* pOutputPCMFile)
{
int sampIdx; /* the sample position in the output circular buffer */
int k1, k2, k3; /* position in output buffer for next write operation */
int numSamps1, numSamps2, numSamps3; /* number of samples that have to written out*/
int cSampsWritten; /* return of fwrite call */
int tmpDiff; /* temporary variable */
/* find the sample position of the start/end sample of the utterance in the circular buffer */
sampIdx = decisionSampNum % pOutBuf->len;
switch (curDecisionState)
{
case ACTIVE:
case INACTIVE:
/* Flush out all but the last buffer with the appropriate decision logic */
/* update the value of previous decision state */
*pPrevDecisionState = curDecisionState;
if (sampIdx < pOutBuf->headIdx)
{
/* Circular buffer wrapped around. Index positions (sampIdx < tailIdx < headIdx) */
k1 = pOutBuf->headIdx;
numSamps1 = (pOutBuf->len - pOutBuf->headIdx);
if (ACTIVE == curDecisionState)
{
/* zero out samples before writing */
ippsZero_16s(&(pOutBuf->pBuf[k1]), numSamps1);
}
cSampsWritten = fwrite(&(pOutBuf->pBuf[k1]), sizeof(Ipp16s), numSamps1, pOutputPCMFile);
k2 = 0;
numSamps2 = sampIdx;
if (ACTIVE == curDecisionState)
{
/* zero out samples before writing */
ippsZero_16s(&(pOutBuf->pBuf[k2]), numSamps2);
}
cSampsWritten = fwrite(&(pOutBuf->pBuf[k2]), sizeof(Ipp16s), numSamps2, pOutputPCMFile);
k3 = sampIdx;
numSamps3 = (pOutBuf->tailIdx - cLookAheadSamps) - sampIdx + 1;
if (INACTIVE == curDecisionState)
{
/* zero out samples before writing */
ippsZero_16s(&(pOutBuf->pBuf[k3]), numSamps3);
}
cSampsWritten = fwrite(&(pOutBuf->pBuf[k3]), sizeof(Ipp16s), numSamps3, pOutputPCMFile);
}
else
{
/* Circular buffer pointer positions are (headIdx < sampIdx) */
k1 = pOutBuf->headIdx;
numSamps1 = (sampIdx - pOutBuf->headIdx);
if (ACTIVE == curDecisionState)
{
/* zero out samples before writing */
ippsZero_16s(&(pOutBuf->pBuf[k1]), numSamps1);
}
cSampsWritten = fwrite(&(pOutBuf->pBuf[k1]), sizeof(Ipp16s), numSamps1, pOutputPCMFile);
k2 = sampIdx;
if (pOutBuf->tailIdx < pOutBuf->headIdx)
{
/* Circular buffer wrapped around. Index positions are (tailIdx < headIdx < sampIdx) */
numSamps2 = pOutBuf->len - sampIdx;
if (INACTIVE == curDecisionState )
{
/* zero out samples before writing */
ippsZero_16s(&(pOutBuf->pBuf[k2]), numSamps2);
}
cSampsWritten = fwrite(&(pOutBuf->pBuf[k2]), sizeof(Ipp16s), numSamps2, pOutputPCMFile);
k3 = 0;
numSamps3 = (pOutBuf->tailIdx - cLookAheadSamps) + 1;
if (INACTIVE == curDecisionState)
{
/* zero out samples before writing */
ippsZero_16s(&(pOutBuf->pBuf[k3]), numSamps3);
}
cSampsWritten = fwrite(&(pOutBuf->pBuf[k3]), sizeof(Ipp16s), numSamps3, pOutputPCMFile);
}
else
{
/* Circular buffer pointer positions are (headIdx < sampIdx < tailIdx) */
numSamps2 = (pOutBuf->tailIdx - cLookAheadSamps) - sampIdx + 1;
if (INACTIVE == curDecisionState)
{
/* Zero out samples before writing */
ippsZero_16s(&(pOutBuf->pBuf[k2]), numSamps2);
}
cSampsWritten = fwrite(&(pOutBuf->pBuf[k2]), sizeof(Ipp16s), numSamps2, pOutputPCMFile);
}
}
/* reset the headIdx after data has been flushed out */
pOutBuf->headIdx = (pOutBuf->tailIdx - cLookAheadSamps) + 1;
break;
case NODECISION:
/* If the output buffer is full flush out one frame to make space for the next input frame */
tmpDiff = pOutBuf->tailIdx - pOutBuf->headIdx;
if ( (-1 == tmpDiff) || ((pOutBuf->len - 1) == tmpDiff) )
{
/* buffer full, so flush one buffer to make room for the next buffer*/
k1 = pOutBuf->headIdx;
numSamps1 = cLookAheadSamps;
if (INACTIVE == *pPrevDecisionState)
{
/* Zero out samples before writing */
ippsZero_16s(&(pOutBuf->pBuf[k1]), numSamps1);
}
cSampsWritten = fwrite(&(pOutBuf->pBuf[k1]), sizeof(Ipp16s), numSamps1, pOutputPCMFile);
/* adjust the head pointer */
pOutBuf->headIdx += cLookAheadSamps;
if (pOutBuf->headIdx >= pOutBuf->len)
{
pOutBuf->headIdx = 0;
}
}
break;
case END_OF_STREAM:
/* flush out all remaining data in output buffer since the input stream has ended */
if (pOutBuf->tailIdx < pOutBuf->headIdx)
{
/* wrapped around circular buffer (tailIdx < headIdx) */
k1 = pOutBuf->headIdx;
numSamps1 = (pOutBuf->len - pOutBuf->headIdx);
if (INACTIVE == *pPrevDecisionState)
{
/* zero out samples before writing */
ippsZero_16s(&(pOutBuf->pBuf[k1]), numSamps1);
}
cSampsWritten = fwrite(&(pOutBuf->pBuf[k1]), sizeof(Ipp16s), numSamps1, pOutputPCMFile);
k2 = 0;
numSamps2 = pOutBuf->tailIdx + 1;
if (INACTIVE == *pPrevDecisionState)
{
/* zero out samples before writing */
ippsZero_16s(&(pOutBuf->pBuf[k2]), numSamps2);
}
cSampsWritten = fwrite(&(pOutBuf->pBuf[k2]), sizeof(Ipp16s), numSamps2, pOutputPCMFile);
}
else
{
/* circular buffer not wrapped (headIdx < tailIdx) */
k1 = pOutBuf->headIdx;
numSamps1 = (pOutBuf->tailIdx - pOutBuf->headIdx + 1);
if (INACTIVE == *pPrevDecisionState)
{
/* zero out samples before writing */
ippsZero_16s(&(pOutBuf->pBuf[k1]), numSamps1);
}
cSampsWritten = fwrite(&(pOutBuf->pBuf[k1]), sizeof(Ipp16s), numSamps1, pOutputPCMFile);
}
/* reset circular buffer pointers */
pOutBuf->headIdx=0;
pOutBuf->tailIdx=-1;
break;
default:
break;
}
}
#endif /* CHOP_SILENCE */
/********************************************************************************
// Name: OUT_WriteEndPoints
// Description: Write out the start/end endpoints (frame/sample number pairs) if the curDecisionState
// is either ACTIVE or INACTIVE. See Notes.
//
// Input Arguments:
// decFrame - absolute frame number where either the start/end
// of utterance has been detected. (-1) otherwise.
// decisionSampNum - absolute sample number where either the start/end
// of utterance has been detected. (-256) otherwise.
// decisionState - indicates the state of the VAD decision.
// Output Arguments:
// pOutputTextFile - file pointer of the output ascii file
//
// Returns: None
//
// Notes: The start frame/sample number indicates that it is the frame/sample where
// the utterance start was detected.
// The end frame/sample number indicates that it is the frame/sample just after
// the utterance end has been detected, i.e, this is a silence frame/sample.
//
********************************************************************************/
void OUT_WriteEndPoints(int decisionFrameNum,int decisionSampNum,VADDecisionState decisionState,FILE* pOutputTextFile)
{
if (ACTIVE == decisionState)
{
fprintf(pOutputTextFile,"%d(%d)", decisionFrameNum,decisionSampNum);
}
else if (INACTIVE == decisionState)
{
fprintf(pOutputTextFile," %d(%d)\n", decisionFrameNum,decisionSampNum);
}
}
/* EOF */
?? 快捷鍵說明
復制代碼
Ctrl + C
搜索代碼
Ctrl + F
全屏模式
F11
切換主題
Ctrl + Shift + D
顯示快捷鍵
?
增大字號
Ctrl + =
減小字號
Ctrl + -