Microsoft/Windows2003-3790
Microsoft/Windows2003-3790
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
master
Windows2003-3790/enduser/speech/sapi/cpl/silence.cpp

886 lines
28 KiB
C++
Raw Permalink Normal View History

First commit
2001-01-01 00:00:00 +01:00
/*********************************************************************
Silence.Cpp - Code for detecting silence on an incoming audio stream
begun 5/14/94 by Mike Rozak
Modified 12/10/96 by John Merrill to fix up alignment problems
*/
#include "stdafx.h"
#include <malloc.h>
#include "silence.h"
// temporary
#pragma warning(disable: 4100 4244)
/*********************************************************************
LowPassFilter - This low-pass filters 16-bit mono PCM data from one
buffer into another.
inputs
short *lpSrc - Source buffer
DWORD dwNumSamples - Number of samples in the source buffer
short *lpDst - Destination buffer. This will be filled in
with a low-passed version. It will have about an 8
sample lag. This must be as large as lpSrc.
short *psMax - Filled in with the new maximum.
If NULL then nothing is copied.
short *psMin - Filled in with the new minimum
If NULL then nothing is copied.
short *psAvg - Filled in with the new average
If NULL then nothing is copied.
DWORD dwSamplesPerSec
returns
DWORD - Number of samples returned. This will be <= dwNumSamples,
possible dwNumSamples - 7.
*/
DWORD LowPassFilter (short *lpSrc, DWORD dwNumSamples, short *lpDst,
short *psMax, short *psMin, short *psAvg, DWORD dwSamplesPerSec)
{
SPDBG_FUNC( "LowPassFilter" );
DWORD i;
long lSum;
short sSum, sMax, sMin;
short *lpLag;
BOOL fLow = (dwSamplesPerSec < 13000);
#define SHIFTRIGHT (fLow ? 3 : 4) // # bits to shift right.
#define WINDOWSIZE (1 << SHIFTRIGHT) // # samples
if (dwNumSamples < (DWORD) (WINDOWSIZE+1))
return 0;
// take the first 8 samples and average them together.
lSum = 0;
for (i = 0; i < (DWORD) WINDOWSIZE; i++)
lSum += lpSrc[i];
sSum = (short) (lSum >> SHIFTRIGHT);
//loop through the rest of the samples
lpLag = lpSrc;
lpSrc += WINDOWSIZE;
dwNumSamples -= WINDOWSIZE;
lSum = 0; // total
sMax = -32768;
sMin = 32767;
for (i = 0;dwNumSamples; lpSrc++, lpDst++, lpLag++, i++, dwNumSamples--) {
sSum = sSum - (*lpLag >> SHIFTRIGHT) + (*lpSrc >> SHIFTRIGHT);
// sSum = *lpSrc; // Dont do any filtering at all
*lpDst = sSum;
lSum += sSum;
if (sSum > sMax)
sMax = sSum;
if (sSum < sMin)
sMin = sSum;
};
// whow much did we do
if (psMax)
*psMax = sMax;
if (psMin)
*psMin = sMin;
if (psAvg && i)
*psAvg = (short) (lSum / (long) i);
return i;
}
/*********************************************************************
QuantSamples - This quantizes the samples to +1, 0, or -1 (in place),
depedning if the given value is:
> sPositive then +1
< sNegative then -1
else 0
inputs
short *pSamples - Samples
DWORD dwNumSamples - Number of samples
short sPositive - Positive threshhold
short sNegative - Negative threshhold
returns
none
*/
void QuantSamples (short *pSamples, DWORD dwNumSamples,
short sPositive, short sNegative)
{
SPDBG_FUNC( "QuantSamples" );
while (dwNumSamples) {
if (*pSamples > sPositive)
*pSamples = 1;
else if (*pSamples < sNegative)
*pSamples = -1;
else
*pSamples = 0;
pSamples++;
dwNumSamples--;
};
}
/*********************************************************************
FindZC - This searches through the samples for the first zero crossing.
The returned point will have its previous sample at <= 0, and the
new one at >0.
inputs
short *pSamples - Samples;
DWORD dwNumSamples - Number of samples
returns
DWORD - first sampe number which is positive, or 0 if cant find
*/
DWORD FindZC (short *pSamples, DWORD dwNumSamples)
{
SPDBG_FUNC( "FindZC" );
DWORD i;
for (i = 1; i < dwNumSamples; i++)
if ((pSamples[i] > 0) && (pSamples[i-1] <= 0))
return i;
// else cant find
return 0;
}
/*********************************************************************
CompareSegments - This compares two wave segments and sees how much
alike they are, returning a confidence that they are the same.
inputs
short *pA - Samples. This assumes that the samples
are -1, 0, or +1.
short *pB - Samples for B. Should be -1, 0, or +1
DWORD dwNumSamples - Number of samples in each of them
returns
WORD - Confidence from 0 to 0xffff (highest confidence)
Notes about the algo: Each sample will score a "similarity point"
for like signs, or if one of the values is a 0.
*/
WORD CompareSegments (short *pA, short *pB, DWORD dwNumSamples)
{
SPDBG_FUNC( "CompareSegments" );
DWORD dwSimilar = 0;
DWORD dwLeft;
for (dwLeft = dwNumSamples; dwLeft; pA++, pB++, dwLeft--)
if ((*pA == *pB) || (*pA == 0) || (*pB == 0))
dwSimilar++;
return (WORD) ((dwSimilar * 0xffff) / dwNumSamples);
}
/*********************************************************************
FindMostLikelyWaveLen - This Searches through wave data and finds the
most likeley wavelength for voiced audio. it returns a condifence
score from 0 to ffff (ffff is 100% positive).
inputs
short *pSamples - Samples
DWORD dwNumSamples - Number of samples
DWORD dwMinWaveLen - Minimum accepatble wavelength
DWORD dwMaxWaveLen - Maximum acceptable wavelength
WORD *pwConfidence - Filled in with confidence rating.
returns
DWORD - Wavelength found. 0 if can't deteermine anything
*/
DWORD FindMostLikelyWaveLen (short *pSamples, DWORD dwNumSamples,
DWORD dwMinWaveLen, DWORD dwMaxWaveLen, WORD *pwConfidence)
{
SPDBG_FUNC( "FindMostLikelyWaveLen" );
#define NUMCOMP (3)
DWORD dwFirstZC, i;
DWORD dwBestWaveLen;
WORD wBestConfidence;
DWORD dwCurZC, dwCurWaveLen, dwTemp;
WORD wConf, wTemp;
// Step one, find the first zero crossing
dwFirstZC = FindZC (pSamples, dwNumSamples);
if (!dwFirstZC)
return 0; // error
// Start at a minimum-wavelength away and start finding a wave
// which repeats three times and compares well.
dwBestWaveLen = 0; // best wavelength found so far
wBestConfidence = 0; // confidence of the best wavelength
dwCurWaveLen = dwMinWaveLen;
while (dwCurWaveLen <= dwMaxWaveLen) {
// Try the first comparison
dwCurZC = dwFirstZC + dwCurWaveLen;
if (dwCurZC >= dwNumSamples)
break; // no more samples left
// find first zero crossing from the current wavelen
dwTemp = FindZC (pSamples + dwCurZC, dwNumSamples - dwCurZC);
if (!dwTemp)
break; // no more samples left
dwCurZC += dwTemp;
dwCurWaveLen += dwTemp;
// Make sure that we have three wavelength's worth
if ((dwFirstZC + (NUMCOMP+1)*dwCurWaveLen) >= dwNumSamples)
break; // cant compare this
// Do two confidence tests and multiply them toegther to
// get the confidence for this wavelength
wConf = 0xffff;
for (i = 0; i < NUMCOMP; i++) {
wTemp = CompareSegments (pSamples + dwFirstZC /* + i * dwCurWaveLen */,
pSamples + (dwFirstZC + (i+1) * dwCurWaveLen), dwCurWaveLen);
wConf = (WORD) (((DWORD) wConf * (DWORD) wTemp) >> 16);
};
// If we're more confident about this one than others then use it
if (wConf >= wBestConfidence) {
wBestConfidence = wConf;
dwBestWaveLen = dwCurWaveLen;
};
// Up the current wavelength just a tad
dwCurWaveLen++;
};
*pwConfidence = wBestConfidence;
return dwBestWaveLen;
}
/*********************************************************************
IsSegmentVoiced - This detects if the segment if voiced or not.
inputs
short *pSamples - Sample data
DWORD dwNumSamples - number of samples
DWORD dwSamplesPerSec - Number of sample sper second
WORD wMinConfidence - Minimum condifence
returns
BOOL - TRUE if its definately voiced, FALSE if not or cant tell
*/
BOOL CSilence::IsSegmentVoiced (short *pSamples, DWORD dwNumSamples,
DWORD dwSamplesPerSec, WORD wMinConfidence, short *asFiltered)
{
SPDBG_FUNC( "CSilence::IsSegmentVoiced" );
//#define FILTERNUM (1024) // max # samples i nthe filter
//#define MAXVOICEHZ (300) // maximum voicce pitchm in hz
//#define MINVOICEHZ (50) // minimum voice pitch in hz
// #define MINCONFIDENCE (0x6000) // minimum confidence
// This means that 70% of the samples line up from one wavelength
// to another
DWORD dwNumFilter;
//short asFiltered[FILTERNUM];
short sMax, sMin, sAvg;
DWORD dwWaveLen;
WORD wConfidence;
short sPositive, sNegative;
// Filter it first so we just get the voiced audio range
if (dwNumSamples > FILTERNUM)
dwNumSamples = FILTERNUM;
dwNumFilter = LowPassFilter (pSamples, dwNumSamples, asFiltered,
&sMax, &sMin, &sAvg, m_dwSamplesPerSec);
// Truncate the wave samples to +1, 0, -1
sPositive = sAvg;
sNegative = sAvg;
QuantSamples (asFiltered, dwNumFilter, sPositive, sNegative);
// look through the voiced wavelengths for a frequency
dwWaveLen = FindMostLikelyWaveLen (asFiltered, dwNumFilter,
dwSamplesPerSec / m_dwHighFreq, dwSamplesPerSec / MINVOICEHZ,
&wConfidence);
return (dwWaveLen && (wConfidence >= wMinConfidence));
}
/*********************************************************************
TrimMaxAmp - This extracts the maximum amplitude range of the wave file
segment.
inputs
short * lpS - samples to look through
WORD dwNum - number of samples
returns
WORD - maximum amplitude range
*/
WORD NEAR PASCAL TrimMaxAmp (short * lpS, DWORD dwNum)
{
SPDBG_FUNC( "TrimMaxAmp" );
DWORD i;
short sMin, sMax, sTemp;
sMin = 32767;
sMax = (short) -32768;
for (i = dwNum; i; i--) {
sTemp = *(lpS++);
if (sTemp < sMin)
sMin = sTemp;
if (sTemp > sMax)
sMax = sTemp;
};
// If we're clipping at all then claim that we've maxed out.
// Some sound cards have bad DC offsets
if ((sMax >= 0x7f00) || (sMin <= -0x7f00))
return 0xffff;
return (WORD) (sMax - sMin);
}
/********************************************************************
TrimMaxAmpDelta - This extracts the maximum amplitude range and
calculates the maximum delta of the wave file
segment.
inputs
PBLOCKCHAR pBlockChar - Pointer to a block characteristic
structure which is filled in.
short * lpS - deltas to look through
WORD dwNum - number of samples
returns
nothing
*/
void TrimMaxAmpDelta(PBLOCKCHAR pBlockChar, short *lpS, DWORD dwNum)
{
SPDBG_FUNC( "TrimMaxAmpDelta" );
DWORD i;
WORD wMax = 0;
WORD wTemp;
short sMin, sMax, sCur, sLast;
// BUGFIX: 4303 Merge TrimMaxAmp and TrimMaxDelta
sLast = sMin = sMax = *(lpS++);
for (i = dwNum - 1; i; i--, sLast = sCur) {
sCur = *(lpS++);
// TrimMaxAmp
if (sCur < sMin)
sMin = sCur;
if (sCur > sMax)
sMax = sCur;
// TrimMaxDelta
wTemp = sCur > sLast ? (WORD) (sCur - sLast) : (WORD) (sLast - sCur);
if (wTemp > wMax)
wMax = wTemp;
}
// If we're clipping at all then claim that we've maxed out.
// Some sound cards have bad DC offsets
pBlockChar->wMaxLevel = ((sMax >= 0x7F00) || (sMin <= -0x7F00)) ? 0xFFFF : (WORD) (sMax - sMin);
pBlockChar->wMaxDelta = wMax;
} /* End of TrimMaxAmpDelta() */
/*********************************************************************
GetBlockChar - This gets the characteristics of a block of audio.
This characteristics can then be used to determine if the block
is silent or not.
inputs
short *lpS - sample data
DWORD dwNum - number of samples
PBLOCKCHAR pBlockChar - Pointer to a block characteristic
structure which is filled in.
BOOL fTestVoiced - Voicce testing will only be done if
this is TTRUE (in order to save processor).
returns
none
*/
void GetBlockChar(short *lpS, DWORD dwNum, PBLOCKCHAR pBlockChar, BOOL fTestVoiced)
{
SPDBG_FUNC( "GetBlockChar" );
// BUGFIX: 4303 Merge TrimMaxAmp and TrimMaxDelta
TrimMaxAmpDelta(pBlockChar, lpS, dwNum);
pBlockChar->bIsVoiced = pBlockChar->bHighLevel =
pBlockChar->bHighDelta = SIL_UNKNOWN;
}
/*********************************************************************
IsBlockSound - This detects whether the block is silent or not.
inputs
PBLOCKCHAR pBlockInQuestion - Block in question. This has the
bHighLevel and bHighDelta flags modified
PBLOCKCHAR pBlockSilence - Silent block
BOOL fInUtterance - TRUE if we're in an utterance (which
means be more sensative), FALSE if we're not
returns
BOOL - TTRUE if has sound, FALSE if it is silent
*/
BOOL IsBlockSound (PBLOCKCHAR pBlockInQuestion, PBLOCKCHAR pBlockSilence,
BOOL fInUtterance)
{
SPDBG_FUNC( "IsBlockSound" );
#ifdef SOFTEND // Use so that catches a soft ending to phrases
#define SENSINV_THRESHHOLD_LEVEL(x) (((x)/4)*3)
#define SENSINV_THRESHHOLD_DELTA(x) (((x)/4)*3)
#else
#define SENSINV_THRESHHOLD_LEVEL(x) ((x)/2)
#define SENSINV_THRESHHOLD_DELTA(x) ((x)/2)
#endif
#define NORMINV_THRESHHOLD_LEVEL(x) ((x)/2)
#define NORMINV_THRESHHOLD_DELTA(x) ((x)/2)
if (fInUtterance) {
pBlockInQuestion->bHighLevel =
SENSINV_THRESHHOLD_LEVEL(pBlockInQuestion->wMaxLevel) >= pBlockSilence->wMaxLevel;
pBlockInQuestion->bHighDelta =
SENSINV_THRESHHOLD_DELTA(pBlockInQuestion->wMaxDelta) >= pBlockSilence->wMaxDelta;
}
else {
pBlockInQuestion->bHighLevel =
NORMINV_THRESHHOLD_LEVEL(pBlockInQuestion->wMaxLevel) >= pBlockSilence->wMaxLevel;
pBlockInQuestion->bHighDelta =
NORMINV_THRESHHOLD_DELTA(pBlockInQuestion->wMaxDelta) >= pBlockSilence->wMaxDelta;
};
return pBlockInQuestion->bHighLevel || pBlockInQuestion->bHighDelta;
}
/*********************************************************************
ReEvaluateSilence - This takes the values used for silence and re-evaluates
them based upon new data which indicates what silence is. It
automatically adjusts to the noise level in the room over a few seconds.
NOTE: This should not be called when an utterance is happening, or
when it might be starting.
inputs
PBLOCKCHAR pSilence - This is the silence block, and should
start out with values in it. It will be modified
so to incorporate the new silence information.
PBLOCKCHAR pNew - New block which is known to be silence.
BYTE bWeight - This is the weighting of the new block
in influencing the old block, in a value from 0 to 255.
256 means that the value of the new silence completely
overpowers the old one, 0 means that it doesnt have
any affect.
returns
none
*/
void ReEvaluateSilence (PBLOCKCHAR pSilence, PBLOCKCHAR pNew,
BYTE bWeight)
{
SPDBG_FUNC( "ReEvaluateSilence" );
#define ADJUST(wOrig,wNew,bWt) \
(WORD) (( \
((DWORD) (wOrig) * (DWORD) (256 - (bWt))) + \
((DWORD) (wNew) * (DWORD) (bWt)) \
) >> 8);
pSilence->wMaxLevel = ADJUST (pSilence->wMaxLevel,
pNew->wMaxLevel, bWeight);
pSilence->wMaxDelta = ADJUST (pSilence->wMaxDelta,
pNew->wMaxDelta, bWeight);
// If it's way too silence (and too good to be true) then assume
// a default silece
// if (!pNew->wMaxLevel && !pNew->wMaxDelta) {
// if (pSilence->wMaxLevel < 2500)
// pSilence->wMaxLevel = 2500;
// if (pSilence->wMaxDelta < 400)
// pSilence->wMaxDelta = 400;
// }
}
/*********************************************************************
WhatsTheNewState - This takes in a stream of bit-field indicating which
of the last 32 blocks were detected as having sound, and what our
state was the last time this was called (utterance or not). It then
figureous out if we're still in an utterance, or we just entered one.
It also says how many buffers ago that was.
inputs
DWORD dwSoundBits - This is a bit-field of the last 32
audio blocks. A 1 in the field indicates that there was
sound there, a 0 indicates no sound. The low bit
corresponds to the most recent block, and high bit
the oldest.
DWORD dwVoicedBits - Just like sound bits except that it indicates
voiced sections of sound.
BOOL fWasInUtterance - This is true is we had an utterance
the last time this called, FALSE if there was silence
BOOL fLongUtterance - If this is a long utterance then dont
react for 1/4 second, otherwise use 1/8 second for
short utterance
WORD wBlocksPerSec - How many of the above-mentioned blocks
fit into a second.
WORD *wStarted - If a transition occurs from no utterance to
an utterance, then this fills in the number of of blocks
ago that the utterance started, into *wStarted. Otherwise
it is not changed.
WORD wReaction - Reaction time (in blocks) after an utterance is
finished
returns
BOOL - TRUE if we're in an utterance now, FALSE if we're in silence
*/
BOOL CSilence::WhatsTheNewState (DWORD dwSoundBits, DWORD dwVoicedBits,
BOOL fWasInUtterance, BOOL fLongUtterance,
WORD wBlocksPerSec, WORD *wStarted, WORD wReaction)
{
SPDBG_FUNC( "CSilence::WhatsTheNewState" );
WORD wCount, wOneBits;
WORD wTimeToCheck;
DWORD dwTemp, dwMask;
if (fWasInUtterance)
wTimeToCheck = wReaction;
else
wTimeToCheck = (wBlocksPerSec/4); // 1/4 second
if (!wTimeToCheck)
wTimeToCheck = 1;
for (wOneBits = 0, wCount = wTimeToCheck, dwTemp = dwSoundBits;
wCount;
dwTemp /= 2, wCount--)
if (dwTemp & 0x01)
wOneBits++;
if (fWasInUtterance) {
// If we were in an utterance, then we still are in an utterance
// UNLESS the number of bits which are turned on for the last
// 0.5 seconds is less that 1/4 of what should be turned on.
if ( (wOneBits >= 1))
return TRUE;
else
return FALSE;
}
else {
// We are in silence. We cannot possible go into an utterance
// until the current block is voicced
if (!(dwVoicedBits & 0x01))
return FALSE;
// If we were in silence then we're still in silence
// UNLESS the number of bits which are turned on for the last
// 0.5 seconds is more than 1/2 of what should be turned on.
// If so, then start the utterance 0.75 seconds ago.
if (wOneBits >= (wTimeToCheck / 2)) {
// we're not in an utterance
// Look back until get 1/8 second of silence, and include
// that in the data returned
dwTemp = dwSoundBits;
// dwMask = (1 << (wBlocksPerSec / 8)) - 1;
// for (wCount = wBlocksPerSec/8; dwTemp & dwMask; dwTemp >>= 1, wCount++);
dwMask = (1 << (wBlocksPerSec / m_wAddSilenceDiv)) - 1;
for (wCount = wBlocksPerSec/m_wAddSilenceDiv; dwTemp & dwMask; dwTemp >>= 1, wCount++);
*wStarted = wCount;
return TRUE;
}
else
return FALSE;
};
}
/*********************************************************************
CSilence::CSilence - This creates the silence class.
inputs
WORD wBlocksPerSec - Number of blocks per second. The blocks
will be passed down through AddBlock().
returns
class
*/
CSilence::CSilence (WORD wBlocksPerSec)
{
SPDBG_FUNC( "CSilence::CSilence" );
m_wBlocksPerSec = min(wBlocksPerSec, 32); // no more than the # bits in a DWORD
m_wBlocksInQueue = m_wBlocksPerSec; // 1 second worth.
m_wLatestBlock = 0;
m_paBlockInfo = NULL;
m_dwSoundBits = m_dwVoicedBits = 0;
m_fFirstBlock = TRUE;
m_fInUtterance = FALSE;
m_dwUtteranceLength = 0;
m_dwSamplesPerSec = 11025;
}
/*********************************************************************
CSilence::~CSilence - Free up everything.
*/
CSilence::~CSilence (void)
{
SPDBG_FUNC( "CSilence::~CSilence" );
WORD i;
if (m_paBlockInfo) {
for (i = 0; i < m_wBlocksInQueue; i++)
if (m_paBlockInfo[i].pSamples)
free(m_paBlockInfo[i].pSamples);
free(m_paBlockInfo);
}
if (m_pASFiltered)
free(m_pASFiltered);
}
/*********************************************************************
CSilence::Init - This initializes the silence code. It basically
allocates memory. It should be called immediately after the object
is created and then not again.
inputs
none
returns
BOOL - TRUE if succeded, else out of memory
*/
BOOL CSilence::Init(BOOL fPhoneOptimized, DWORD dwSamplesPerSec)
{
SPDBG_FUNC( "CSilence::Init" );
m_dwSamplesPerSec = dwSamplesPerSec;
if (fPhoneOptimized) {
m_wAddSilenceDiv = (WORD) PHADD_BEGIN_SILENCE;
m_dwHighFreq = PHMAXVOICEHZ;
}
else {
m_wAddSilenceDiv = (WORD) PCADD_BEGIN_SILENCE;
m_dwHighFreq = PCMAXVOICEHZ;
}
if ((m_pASFiltered = (short *) malloc((sizeof(short)) * FILTERNUM)) == NULL)
return (FALSE);
// Initialize memory for the blocks and clear it.
if (m_paBlockInfo)
return (TRUE);
m_paBlockInfo = (PBINFO) malloc(m_wBlocksInQueue * sizeof(BINFO));
if (!m_paBlockInfo)
return (FALSE);
if (m_wBlocksInQueue && m_paBlockInfo)
memset(m_paBlockInfo, 0, m_wBlocksInQueue * sizeof(BINFO));
return (TRUE);
} /* End of Init() */
/*********************************************************************
CSilence::AddBlock - This does the following:
- Add the block the the queue. Free up an old block if needed.
The block should be 1/wBlocksPerSec long (about).
- Analyze the block to see if its got sound or is quiet.
- Fill in *wVU with a VU level.
- Return TRUE if we're in an utterance, FALSE if its silence now.
If TRUE then app should call GetBlock() until no more blocks left,
and pass them to the SR engine.
inputs
short *pSamples - Pointer to samples. This memory should
be allocaed with malloc(), and may be freed by the
object.
DWORD dwNumSamples - Number of samples
WORD *wVU - This is fille in with the VU meter for the block
QWORD qwTimeStamp - Time stamp for this buffer.
returns
BOOL - TRUE if an utterance is taking place, FALSE if its silent
*/
BOOL CSilence::AddBlock (short *pSamples, DWORD dwNumSamples,
WORD *wVU, QWORD qwTimeStamp)
{
SPDBG_FUNC( "CSilence::AddBlock" );
BLOCKCHAR bcNew;
BOOL fSound, fUtt;
PBINFO pbInfo;
WORD wUttStart, i;
// Dont add empty blocks
if (!dwNumSamples) {
if (pSamples)
free (pSamples);
return m_fInUtterance;
};
// Analyze the block for characteristics.
GetBlockChar (pSamples, dwNumSamples, &bcNew, !m_fInUtterance);
// fill in the vu
*wVU = bcNew.wMaxLevel;
// see if it's silent or not
if (m_fFirstBlock) {
// first block, so of course its silent
m_bcSilence = bcNew;
m_fFirstBlock = FALSE;
fSound = FALSE;
// BUGFIX 2466 - If it's way too silence (and too good to be true) then assume
// a default silece
if ((m_bcSilence.wMaxLevel < 500) || (m_bcSilence.wMaxDelta < 100)) {
m_bcSilence.wMaxLevel = 2500;
m_bcSilence.wMaxDelta = 400;
};
// If it's way too loud then cut down
if ((m_bcSilence.wMaxLevel > 2500) || (m_bcSilence.wMaxDelta > 1500)) {
m_bcSilence.wMaxLevel = min (m_bcSilence.wMaxLevel, 2500);
m_bcSilence.wMaxDelta = min (m_bcSilence.wMaxDelta, 1500);
};
}
else {
fSound = IsBlockSound (&bcNew, &m_bcSilence, m_fInUtterance);
};
// Test to see if the block is voiced if:
// - The amplitude level is more than background sound
// - We're not yet in an utterance (to save processor)
if (bcNew.bHighLevel && !m_fInUtterance) {
WORD wNoise;
wNoise = (m_dwSamplesPerSec <= 13000) ?
m_wNoiseThresh :
((m_wNoiseThresh / 3) * 2);
bcNew.bIsVoiced = this->IsSegmentVoiced (pSamples, dwNumSamples, m_dwSamplesPerSec, wNoise, m_pASFiltered) ?
SIL_YES : SIL_NO;
}
// add the block
m_dwVoicedBits = (m_dwVoicedBits << 1) |
( (bcNew.bIsVoiced == SIL_YES) ? 1 : 0 );
m_dwSoundBits = (m_dwSoundBits << 1) | (fSound ? 1 : 0);
m_wLatestBlock++;
if (m_wLatestBlock >= m_wBlocksInQueue)
m_wLatestBlock = 0;
pbInfo = m_paBlockInfo + m_wLatestBlock;
if (pbInfo->pSamples)
free (pbInfo->pSamples);
pbInfo->pSamples = pSamples;
pbInfo->dwNumSamples = dwNumSamples;
// BUGFIX: Alignment code. We need to store the timestamp for
// the BEGINNING of the block, not the end!
pbInfo->qwTimeStamp = qwTimeStamp - dwNumSamples * sizeof(WORD);
// What's our utterance state?
fUtt = this->WhatsTheNewState (m_dwSoundBits, m_dwVoicedBits, m_fInUtterance,
m_dwUtteranceLength >= m_wBlocksPerSec,
m_wBlocksPerSec, &wUttStart, m_wReaction);
if (fUtt && !m_fInUtterance) {
// We just entered an utterance, so wUttStart has a valid teerm
// in it. Go through the buffer queue and free all buffers which
// are older than wUttStart. Remembeer, this is a circular buffer
for (i = 0; i < (m_wBlocksInQueue - wUttStart); i++) {
pbInfo = m_paBlockInfo +
( (m_wLatestBlock + i + 1) % m_wBlocksInQueue);
if (pbInfo->pSamples)
free (pbInfo->pSamples);
pbInfo->pSamples = NULL;
};
// Since we just entered an utterance clear the utterance length counter
m_dwUtteranceLength = 0;
};
m_fInUtterance = fUtt;
// Remember how long this utterance has done on. Long utterances
// deserve more patience as far as silence goes
m_dwUtteranceLength++;
// Adjust the silence level if we're not in an utterance
// Requiring !fSound so that we dont accidentally indclude any
// utterance sections in the sound calculations
if (!m_fInUtterance /* && !fSound */) {
ReEvaluateSilence (&m_bcSilence, &bcNew,
255 / m_wBlocksPerSec);
}
else if (m_dwUtteranceLength >= ((DWORD)m_wBlocksPerSec * 30))
// if we have a very long utterance (> 30 second) then it's not
ReEvaluateSilence (&m_bcSilence, &bcNew, 255 / m_wBlocksPerSec);
// done
return m_fInUtterance;
}
/*********************************************************************
CSilence::ExpectNoiseChange - Sent to the silence detection algorithm
when it should expect the noise floor to go up/down.
inputs
WORD wValue - Amount that noise floor should change.
0x100 = no change. > 0x100 => louder, < 0x100 => quieter
returns
*/
void CSilence::ExpectNoiseChange (WORD wValue)
{
SPDBG_FUNC( "CSilence::ExpectNoiseChange" );
DWORD dwTemp;
dwTemp = ((DWORD) m_bcSilence.wMaxLevel * wValue) >> 8;
if (dwTemp > 0xffff)
dwTemp = 0xffff;
m_bcSilence.wMaxLevel = (WORD) dwTemp;
dwTemp = ((DWORD) m_bcSilence.wMaxDelta * wValue) >> 8;
if (dwTemp > 0xffff)
dwTemp = 0xffff;
m_bcSilence.wMaxDelta = (WORD) dwTemp;
}
/*********************************************************************
CSilence::GetBlock - This gets a block from the queue. This will fail
if there are no more blocks left to get OR if there's not utterance.
inputs
DWORD *pdwNumSamples - If a block is returned then this
will be filled in with the number of samples in the block.
QWORD *pqwTimeStamp - Filled in woth the time-stamp for the
buffer.
returns
short * - Pointer to a block of samples. This memory is the
caller's property and can be freed with free().
*/
short * CSilence::GetBlock (DWORD *pdwNumSamples, QWORD * pqwTimeStamp)
{
SPDBG_FUNC( "CSilence::GetBlock" );
PBINFO pbInfo;
WORD i, wCount;
short *pSamples;
if (!m_fInUtterance)
return NULL;
// find the first occurance
i = (m_wLatestBlock + 1) % m_wBlocksInQueue;
for (wCount = m_wBlocksInQueue; wCount;
i = ((i < (m_wBlocksInQueue-1)) ? (i+1) : 0), wCount-- ) {
pbInfo = m_paBlockInfo + i;
if (pbInfo->pSamples) {
*pdwNumSamples = pbInfo->dwNumSamples;
*pqwTimeStamp = pbInfo->qwTimeStamp;
pSamples = pbInfo->pSamples;
pbInfo->pSamples = NULL;
return pSamples;
};
};
// if got here then couldnt find anything
return NULL;
}
/*********************************************************************
CSilence::KillUtterance - Kills an exitsing utterance.
inputs
none
returns
none
*/
void CSilence::KillUtterance (void)
{
SPDBG_FUNC( "CSilence::KillUtterance" );
m_fInUtterance = FALSE;
m_dwSoundBits = 0;
m_dwVoicedBits = 0;
}
Reference in New Issue Copy Permalink