vad.cpp

Ir a la documentación de este archivo.

#include "vad.h"
#include <cassert>



bool
vad::Reset (const vad_config & cfg, DOUBLE snr, FLOAT FrameLen, XFFT_WIN WinType)
{ 
    //Comprobamos un par de cosas
    assert ((m_LTWindowLen-1)%2 == 0);  //Ventana de tamaño impar
    assert ((m_LTWindowLen-1/2) >= m_ActWindowLen); //Ventana de actualización menor que media LTSE
    
    //Debemos destruir lo que ya esté construido
    Destruct ();
    
    //Primero las fáciles:
    m_FrameLen = FrameLen;
    m_WinType = WinType;
    m_SNR = snr;    //La SNR inicial se debe poner a huevo
    
    m_SNR0 = cfg.SNR0;
    m_SNR1 = cfg.SNR1;
    m_gamma0 = cfg.gamma0;
    m_gamma1 = cfg.gamma1;
    
    m_ActWindowLen = cfg.ActWindowLen;
    m_LTWindowLen = cfg.LTWindowLen;
    m_Handover = cfg.Handover;
    m_offset = cfg.offset;
    m_Nalfa = cfg.Nalfa;
    m_SNRalfa = cfg.SNRalfa;
    
    //Ahora, los que requieren inicialización
    m_NumSil = 0;
    m_NumVoice = 0;
    m_HoSil = 0;
    m_NoisePow = 0;
    m_SignalPow = 0;
    m_NoiseInitFrames = 0;
    m_bufferedFrames = 0;
    
    //Por último, los elementos que requieren memoria
    m_fftObject = rfft_construct (FrameLen, FrameLen, FFT_DIRECT, 1, WinType, NULL);
    m_Nfft = rfft_getfftnp(m_fftObject)/2;  //Tomamos el verdadero valor de Nfft (entre 2 por ser simétrica)
    
    m_NoiseFFT = (pDOUBLE) xmalloc (m_Nfft*sizeof(DOUBLE));
    m_NoiseFFTAct = (pDOUBLE) xmalloc (m_Nfft*sizeof(DOUBLE));
    m_LTSE = (pDOUBLE) xmalloc (m_Nfft*sizeof(DOUBLE));
    
    m_memFFT.Resize(m_LTWindowLen, m_Nfft);
    //Es importante inicializar el buffer para que luego al calcular la LTSE
    //de las primeras tramas del archivo, no haya problemas porque no existen
    //tramas anteriores.
    for (INT i = 0; i < m_LTWindowLen; ++i)
        //El Resize se encrga de que m_memFFT::m_head apunte al elemento 0
        memset (m_memFFT[i], 0, m_Nfft*sizeof(DOUBLE));
    
    //Comprobamos que no haya errores
    if (   m_fftObject == NULL
        || m_NoiseFFT == NULL
        || m_NoiseFFTAct == NULL
        || m_LTSE == NULL)
    {
        Destruct ();
        return false;
    }
    
    //Inicializamos las memorias
    memset (m_NoiseFFT, 0, m_Nfft*sizeof(DOUBLE));
    memset (m_NoiseFFTAct, 0, m_Nfft*sizeof(DOUBLE));
    memset (m_LTSE, 0, m_Nfft*sizeof(DOUBLE));
    
    return true;
}

void
vad::NoiseInit (pDOUBLE frame)
{
    //Calculamos la FFT de la nueva trama
    rfft_rfft (m_fftObject, frame);
    rfft_mag (m_fftObject);
    pDOUBLE newFFT = rfft_getrevec (m_fftObject);
    
    //Actualizamos el espectro de ruido.
    //Hay que des-normalizar, sumar y re-normalizar,
    //todo ello en un único paso
    DOUBLE rescale = DOUBLE(m_NoiseInitFrames)/DOUBLE(m_NoiseInitFrames+1);
    if (m_NoiseInitFrames != 0)
        for (INT i = 0; i < m_Nfft; ++i)
            m_NoiseFFT[i] = m_NoiseFFT[i]*rescale + newFFT[i]/(m_NoiseInitFrames+1);
    else
        for (INT i = 0; i < m_Nfft; ++i)
            m_NoiseFFT[i] = newFFT[i];
    
    //Actualizamos la potencia de ruido
    for (INT i = 0; i < m_Nfft; ++i)
        m_NoisePow += m_NoiseFFT[i]*m_NoiseFFT[i];
    m_NoisePow /= m_Nfft;
    
    //Actualizamos la potencia de señal
    //(se supone que lo que conocemos es la SNR)
    m_SignalPow = pow(10,m_SNR/10) * m_NoisePow;

    ++m_NoiseInitFrames;    //Ahora hay una trama más
}
    
bool
vad::doVAD (pDOUBLE frame)
{
    //Añadimos la trama al buffer
    AddToBuffer (frame);
    
    //Si no se ha llegado a llenar medio buffer,
    //no hagas nada y devuelve silencio. Todavía no
    //se puede calcular nada. Sólo puedes añadir la trama
    //al buffer, cosa que ya has hecho
    if (m_bufferedFrames < (m_LTWindowLen-1)/2)
    {
        ++m_bufferedFrames;
        return false;
    }
    
    //Calculamos la LTSE
    LTSE();
    
    //Calculamos LTSD a partir de LTSE
    DOUBLE ltsd = LTSD();
    
    //Calculamos el umbral que corresponde a la actual SNR
    DOUBLE gamma = Gamma();

    //Ahora comparamos con el umbral para detectar voz
    if (ltsd+m_offset >= gamma)
    {
        ActualizeSignal();
        return true;
    }
    else if (m_HoSil < m_Handover)
    {
        ++m_HoSil; //Parece silencio pero el HandOver está activado
        return true;
    }
    else
    {
        ActualizeNoise();
        return false;
    }
}
        
        
        
void
vad::Destruct()
{
    if (m_NoiseFFT) xfree(m_NoiseFFT);
    if (m_NoiseFFTAct) xfree(m_NoiseFFTAct);
    if (m_LTSE) xfree(m_LTSE);
    if (m_fftObject) rfft_destruct(m_fftObject);
}


DOUBLE
vad::Gamma() const
{
    if (m_SNR <= m_SNR0)
        return m_gamma0;
    else if (m_SNR >= m_SNR1)
        return m_gamma1;
    else
        return ((m_gamma0-m_gamma1)/(m_SNR0-m_SNR1)*m_SNR + m_gamma0 - (m_gamma0-m_gamma1)/(1-m_SNR1/m_SNR0));
}

void
vad::ActualizeSignal()
{
    INT M = (m_NumVoice < m_ActWindowLen) ? m_NumVoice : m_ActWindowLen;
    DOUBLE SignalPAct = 0;
    
    for (int i = (m_LTWindowLen-1)/2-M+1; i <= (m_LTWindowLen-1)/2+1 ; ++i)
    {
        for (INT j = 0; j < m_Nfft; ++j)
            SignalPAct += m_memFFT[i][j]*m_memFFT[i][j];
    }
    SignalPAct /= ((M+1)*m_Nfft);
    m_SignalPow = m_SNRalfa*m_SignalPow + (1-m_SNRalfa)*SignalPAct;
    
    //Conocida la potencia de la señal, se saca la SNR
    m_SNR = 10*log10(m_SignalPow/m_NoisePow);
    
    //Actualizamos los contadores
    ++m_NumVoice;
    m_NumSil = 0;
    m_HoSil = 0;
}

void
vad::ActualizeNoise()
{
    //Borramos los valores anteriores
    memset (m_NoiseFFTAct, 0, m_Nfft*sizeof(DOUBLE));

    INT M = (m_NumSil < m_ActWindowLen) ? m_NumSil : m_ActWindowLen;
    DOUBLE NoisePAct = 0;
    
    for (INT i = (m_LTWindowLen-1)/2-M+1; i <= (m_LTWindowLen-1)/2+1 ; ++i)
    {
        for (INT j = 0; j < m_Nfft; ++j)
        {
            NoisePAct += m_memFFT[i][j]*m_memFFT[i][j];
            m_NoiseFFTAct[j] += m_memFFT[i][j];
        }
    }

    //Normalizamos y ponderamos con los anteriores
    NoisePAct /= ((M+1)*m_Nfft);
    for (INT i = 0; i < m_Nfft; ++i)
        m_NoiseFFT[i] = m_Nalfa*m_NoiseFFT[i] + (1-m_Nalfa)*m_NoiseFFTAct[i]/(M+1);

    m_NoisePow = m_Nalfa*m_NoisePow + (1-m_Nalfa)*NoisePAct;

    //Conocida la potencia de ruido, se saca la SNR
    m_SNR = 10*log10(m_SignalPow/m_NoisePow);

    //Actualizamod los contadores
    ++m_NumSil;
    m_NumVoice = 0;
}

void
vad::AddToBuffer (pDOUBLE frame)
{
    //Calculamos la FFT de la nueva trama
    rfft_rfft (m_fftObject, frame);
    rfft_mag (m_fftObject);
    pDOUBLE newFFT = rfft_getrevec (m_fftObject);
    
    //La añadimos al buffer
    m_memFFT.Push(newFFT);
}

void
vad::LTSE ()
{
    //Borramos el LTSE anterior
    memset (m_LTSE, 0, m_Nfft*sizeof(DOUBLE));
    
    //Y calculamos el nuevo
    for (INT i = 0; i < m_LTWindowLen; ++i)
    {
        for (INT j = 0; j < m_Nfft; ++j)
            if (m_memFFT[i][j] > m_LTSE[j])
                m_LTSE[j] = m_memFFT[i][j];
    }
    //Aunque para las primeras tramas no existan las (LTWindowLen-1)/2 tramas anteriores,
    //si se ha inicializado el buffer de memFFT a cero esto no afecta al cálculo
    //del máximo, y es como si sólo se usaran las tramas posteriores.
}

DOUBLE
vad::LTSD () const
{
    DOUBLE sal = 0;
    for (INT i = 0; i < m_Nfft; ++i)
        sal += (m_LTSE[i]*m_LTSE[i]) / (m_NoiseFFT[i]*m_NoiseFFT[i]);
    sal = 10*log10(sal/m_Nfft);
    return sal;
}

---