vadout.c

Intel开发的IPP库的应用实例

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