Referencia de la Clase vad

Estimación de actividad vocal. Más...

#include <vad.h>

Diagrama de colaboración para vad:


Métodos públicos
	vad ()
	Constructor.
	vad (const vad_config &cfg, DOUBLE snr, FLOAT FrameLen, XFFT_WIN WinType)
	Constructor.
	vad (const vad_config &cfg, DOUBLE snr, FLOAT FrameLen)
	Constructor.
	~vad ()
	Destructor.
bool	Reset (const vad_config &cfg, DOUBLE snr, FLOAT FrameLen, XFFT_WIN WinType=XFFT_WIN_HAMM)
	Inicializa los valores de configuración y la memoria reservada.
void	NoiseInit (pDOUBLE frame)
	Utiliza una trama para la inicialización de ruido.
bool	doVAD (pDOUBLE frame)
	Realiza la decisión VAD sobre la trama.
get-ters y set-ters
Es seguro llamar a estas funciones incluso después de haber inicializado el objeto. Pocas veces tiene sentido hacerlo, pero es seguro.
LONG	getFrameLen () const
	Número de muestras que deben tener las tramas.
INT	getNfft () const
	Número de puntos FFT que se están usando.
INT	getLTWindowLen () const
	Número de tramas usadas para análisis LongTerm.
bool	IsBufferFull () const
	El estado del buffer.
DOUBLE	getNoisePow () const
	Potencia estimada del ruido en este momento.
void	setNoisePow (DOUBLE np)
	Número de muestras que deben tener las tramas.
DOUBLE	getSignalPow () const
	Potencia estimada de la señal en este momento.
void	setSignalPow (DOUBLE sp)
	Número de muestras que deben tener las tramas.
DOUBLE	getSNR () const
	SNR estimada en este momento.
void	setSNR (DOUBLE snr)
DOUBLE	getSNR0 () const
	Límite inferior de SNR.
void	setSNR0 (DOUBLE snr0)
	Número de muestras que deben tener las tramas.
DOUBLE	getSNR1 () const
	Límite superior de SNR.
void	setSNR1 (DOUBLE snr1)
	Número de muestras que deben tener las tramas.
DOUBLE	getGamma0 () const
	Umbral de SNR0.
void	setGamma0 (DOUBLE gamma0)
	Número de muestras que deben tener las tramas.
DOUBLE	getGamma1 () const
	Umbral de SNR1.
void	setGamma1 (DOUBLE gamma1)
	Número de muestras que deben tener las tramas.
INT	getActWindowLen () const
	Número de tramas usadas para actualización de ruido y señal.
void	setActWindowLen (INT ActWindowLen)
	Número de muestras que deben tener las tramas.
FLOAT	getNalfa () const
	Coeficiente de memoria para la actualización del ruido.
void	setNalfa (FLOAT Nalfa)
	Número de muestras que deben tener las tramas.
FLOAT	getSNRalfa () const
	Coeficiente de memoria para la actualización del la señal.
void	setSNRalfa (FLOAT SNRalfa)
	Número de muestras que deben tener las tramas.
DOUBLE	getOffset () const
	offsest
void	setOffset (DOUBLE offset)
	Número de muestras que deben tener las tramas.
INT	getHandover () const
	offsest
void	setHandover (INT Handover)
	Número de muestras que deben tener las tramas.
Métodos protegidos
void	Destruct ()
	Destruye el objeto.
DOUBLE	Gamma () const
	Calcula el umbral de LTSD.
void	ActualizeSignal ()
	Actualiza el modelo de señal.
void	ActualizeNoise ()
	Actualiza el modelo de ruido.
void	AddToBuffer (pDOUBLE frame)
	Añade una trama nueva al buffer.
void	LTSE ()
	Calcula la LTSE del contenido del buffer.
DOUBLE	LTSD () const
	Calcula la LTSD a partir de la LTSE y el espectro de ruido.
Atributos protegidos
Variables asociadas con el enventantado y el análisis FFT
LONG	m_FrameLen
	Longitud de la trama en muestras.
XFFT_WIN	m_WinType
	Tipo de ventana.
pRFFT	m_fftObject
	Objeto de análisis FFT.
INT	m_Nfft
	Número de puntos de las FFT.
buffer2D	m_memFFT
	Array circular de FFT necesario para el cálculo de LTSE.
INT	m_bufferedFrames
	Auxiliar para saber si ya se ha llenado la mitad del buffer;.
Variables asociadas con la señal y el ruido estimados
pDOUBLE	m_NoiseFFT
	Espectro medio del ruido.
INT	m_NoiseInitFrames
	Número de tramas usadas en la inicialización del ruido.
DOUBLE	m_NoisePow
	Potencia estimada del ruido.
DOUBLE	m_SignalPow
	Potencia estimada de la señal.
DOUBLE	m_SNR
	SNR estimada.
DOUBLE	m_SNR0
	Mínima SNR considerada.
DOUBLE	m_SNR1
	Máxima SNR considerada.
INT	m_ActWindowLen
	Número de tramas usadas para actualización de ruido y señal.
FLOAT	m_Nalfa
	Coeficiente de memoria para la actualización del ruido.
FLOAT	m_SNRalfa
	Coeficiente de memoria para la actualización de la SNR.
pDOUBLE	m_NoiseFFTAct
	Usado durante la actualización del espectro de ruido.
Variables asociadas con el algoritmo LTSD
INT	m_LTWindowLen
	Número de tramas usadas para análisis LongTerm.
DOUBLE	m_gamma0
	Umbral asociado a SNR0.
DOUBLE	m_gamma1
	Umbral asociado a SNR1.
INT	m_Handover
	Número de tramas usadas para Hand Over.
LONG	m_NumSil
	Número de tramas silenciosas hasta ahora (para actualizar espectro).
LONG	m_NumVoice
	Número de tramas sonoras hasta ahora (para actualizar espectro).
LONG	m_HoSil
	Contador para HandOver.
DOUBLE	m_offset
	Offset para la LTSD.
pDOUBLE	m_LTSE
	Usado durante el cálculo de la LTSE.
Estructuras de datos
struct	vad_config
	Estructura para inicialización de la clase vad. Más...

Descripción detallada

Descripción

Este programa implementa un algoritmo VAD basado en el cálculo de LTSD (Long Term Spectrum Deviation). La salida del programa es un archivo de marcas, con el mismo nombre que el archivo de sonido original. Cada marca determina un intervalo de voz (etiqueta 'V') o de silencio (etiqueta '_').

El sistema realiza una estimación del espectro de las tramas silenciosas (es decir, el espectro del ruido), y lo compara con el espectro de la trama actual. Si la diferencia supera un umbral, se considera que la trama contiene voz, y si no, que se trata de un silencio. El umbral es adaptativo, y varía en función de la estimación de SNR. De esta forma, puede adaptarse a niveles de ruido cambiantes a lo largo de la señal. Para ello es necesario indicar el menor y mayor valor de SNR esperado, con SNR0 y SNR1 respectivamente.

Cada vez que una trama es clasificada como silencio, se actualiza la estimación del espectro y la potencia de ruido, con un factor de olvido Nalfa. Igualmente, para cada trama clasificada como voz, se actualiza la estimación de SNR con un factor de olvido SNRalfa. De esta forma, se van adaptando los umbrales a las nuevas condiciones de ruido.

Pre-procesado

Es necesario hacer una primera estimación del espectro de ruido y de la relación SNR, antes de empezar a aplicar el algoritmo. Para ello tenemos dos opciones.

Si RealTime no está activado, la inicialización se realiza mediante un pre-procesado y una sencilla detección de silencios por umbral de potencia. todas las tramas clasificadas como silencio son usadas para realizar la estimación del espectro y la potencia de ruido. Igualmente, las tramas clasificadas como voz se utilizan para estimar la potencia de señal. Así se consigue unos valores generales con los que empezar a realizar una detección más precisa. El umbral de este pre-procesado se indica mediante PowThr.

Nota:: El valor de PowThr se especifica en porcentaje. Durante el pre-procesado se estiman los valores máximo y mínimo de la potencia, y el umbral se fija como este porcentaje medido en su rango. Es decir, si indicamos 20% y los valores extremos de potencia son 50 dB y 100 dB, el umbral se fijará en (100-50)*0.2+50=60 dB.

Hay que tener cuidado con el valor de la variable Ninit. Esta variable indica el mínimo número de tramas que han de ser utilizadas para calcular el nivel de ruido de la señal. Si durante el pre-procesaro no se encuentran Ninit tramas clasificadas como silenciosas, el algoritmo no podrá inicializarse, y dará como salida todo-voz (una única marca de voz durante toda la longitud del archivo), presentando un warning a la salida. Por tanto, hay que asegurarse que en los archivos a procesar haya al menos Ninit*FrameRateMs milisegundos de silencio. Si es necesario, se puede reducir el valor de Ninit, pero un valor de inicialización demasiado bajo puede dar lugar también a una mala estimación del espectro de ruido, y por tanto, una mala detección de silencios. Por eso, en este caso, se ha optado por suponer que todo es voz.

Si RealTime está activado, esta inicialización se realiza en línea (aunque no realmente en tiempor real). Se utilizan las primeras Ninit tramas para inicializar el espectro y potencia de ruido. Por lo tanto, es necesario que estas primeras tramas no tengan voz, o la detección de silencios fallará estrepitosamente.

En el caso de la inicialización en línea, no hay forma de conocer la potencia de la señal, por lo que la SNR se tiene que inicializar de otra forma. Si se conoce la SNR aproximada de la señal de antemano, se puede indicar mediante la opción -SNRstart. El algoritmo toma este valor como SNR de partida, y luego ya se irá adaptando según vaya detectando segmentos de voz. Si no se conoce este valor, se toma la media entre SNR0 y SNR1. No es que sea la mejor aproximación, pero es la única que tenemos.

Nota:: Debido a estos problemas a la hora de estimar la potencia de señal, con la inicialización en línea es conveniente que SNRalfa se rebaje un poco, de forma que la potencia de señal se adapte más rápidamente.

Hand-over y post-procesado

El valor Handover controla el número de tramas que han de ser clasificadas como silencio antes de que se decida que realmente es un segmento silencioso. Es decir, las primeras Handover tramas clasificadas como silencio después de un segmento sonoro quedarán incluidas en la marca del segmento sonoro. La cuestión es que es preferible extender las marcas de voz y marcar como voz un trozo de silencio que marcar como silencio un trozo de voz mal clasificado y perder esa información. En cualquier caso, una vez finalizado el algoritmo, se realiza un post-procesado para eliminar todas las marcas de silencio con una duración inferior a MinSilDur y las marcas de voz de duración inferior a MinVocDur.

Nota:: Tal y como se ha implementado, las marcas de silencio y voz se colocan coincidiendo con el principio y final de las tramas detectadas como vocales y silenciosas. Si se quiere que las marcas se coloquen en el centro de las tramas, se deben descomentar las líneas de código correspondientes para sustituir a los comandos de escritura en el archivo de salida.

Tareas Pendientes:: Pruebas exhaustivas: Tomar archivos con silencios marcados (preferiblemente a mano) y pasar el programa. Comparar los resultados con las marcas manuales y las marcas generadas por mrkpf. Detectar errores (inserción, eliminación, precisión)

Tareas Pendientes:: El postprocesado que hemos hecho ¿puede hacerse directamente dentro del algoritmo? Ventajas: puede hacerse en tiempo real y además podemos hacer un merge automático.

Autor:: Erik Lounge <erik.lounge(ARROBA)wanadoo.es>

Versión:

        Version  dd/mm/aa  Autor     Proposito de la edicion
        -------  --------  --------  -----------------------
        1.0.0    04/03/10  ikerl     Codificación inicial

Esta clase se encarga de gestionar un algoritmo de detección de actividad vocal (VAD por sus siglas en inglés) basado en envolvente espectral a largo plazo (LTSE). El algoritmo utilizado es una modificación del presentado en:

Ramirez, Javier and Segura, Jose C. and Benitez, Carmen and de la Torre, Angel and Rubio, Antonio, "Efficient Voice Activity Detection Algorithms Using Long Term Speech Information", Speech Communication, vol. 42, pp. 271-287, 2004.

El algoritmo modificado que está implementado puede encontrarse en:

Luengo, Iker and Navas, Eva and Odriozola, Igor and Saratxaga, Ibon and Hernaez, Inmaculada and Sainz, Iñaki and Erro, Daniel "Modiﬁed LTSE VAD algorithm for applications requiring reduced silence frame misclassiﬁcation", Proc. of LREC 2010

Entre los dos artículos se debería tener una idea bastante maja de cómo va el algoritmo, por lo que aquí sólo voy a tratar de aclarar cuestiones sobre su implementación y configuración. Sin embargo, para entender qué representa cada parámetro de configuración, es necesario dar una visión general de cómo funciona este algoritmo. Ojo, es una descripción muy poco rigurosa, no hay que tomarse todo al pié de la letra. Sólo se explica lo extrictamente necesario.

La LTSE de una trama es una aproximación de la envolvente espectral de la trama más menos una ventana de N tramas por delante y por detrás. esta ventana de 2N+1 tramas, cuya trama central es la actual, es lo que vamos a llamar 'ventana LTSE'. Calculada la LTSE de la trama actual, se compara esta LTSE con el espectro estimado del ruido. Si la diferencia es superior a un umbral $\gamma$ , se considera que la trama contiene voz. Si no, se considera que sólo es ruido.

El umbral $\gamma$ depende de la SNR estimada de la señal. Además, por cada trama que se clasifica como silencio, se actualiza el espectro estimado de ruido y la potencia estimada de ruido. Igualmente, por cada trama clasificada como voz se actualiza la potencia estimada de señal. Con esto, la SNR también se va actualizando.

Por tanto, los elementos clave de este algoritmo son:

La ventana de análisis LTSE, de 2N+1 muestras
El espectro estimado del ruido
La potencia estimada de ruido y de señal
La SNR estimada (que se calcula a partir de las anteriores)
El cálculo del umbral.

Utilización del VAD

El algoritmo consta de de unas tres partes: modelado de ruido, inicializacion del buffer LTSE y el procesado VAD propiamente dicho. Además, antes de todo esto, es necesario configurar el objeto con los parámetros adecuados.

Configuración

Prácticamente toda la configuración que necesita la clase se da mediante un objeto de tipo vad_config. El significado de cada uno de sus elementos se explicará según vayan apareciendo en la documentación. El resto de valores necesarios son los solicitados por la función Reset():

El tamaño de las tramas (en muestras)
El tipo de enventanado de las tramas (ver RFFT)
La SNR inicial

Es necesario proporcionar la SNR inicial, pues el algoritmo no tiene forma alguna de estimarla. Esta SNR inicial puede calcularse mediante un pre-procesado de la señal, o en el peor de los casos, estimarse a huevo. Arréglatelas como quieras, pero el algoritmo la necesita.

Las tramas que se dan al sistema no tienen que estar enventanadas, él mismo ya aplica la ventan correcta. En caso de que las tramas ya estén enventanadas, será necesario indicar XFFT_WIN_NONE como ventana, para evitar que se enventane dos veces. Por defecto, se utiliza ventana de Hamming.

El constructor de vad_config ya define los valores por defecto que se han estimado óptimos hasta el momento, por lo que si se quiere dejar los valores por defecto, basta con no modificar ningún elemento. En caso contrario, reescribir el elemento que se quiere modificar y ya está.

Una forma de inicializar el objeto vad es a través del constructor:

        vad_config cfg;             //Si no modificamos nada usamos los valores por defecto
        vad vad_object(cfg, 80);    //Tramas de 80 muestras

Otra forma es utilizando el constructor por defecto y mediante la función Reset():

        vad vad_object;         //Constructor por defecto
 
        //Hacemos cositas por el camino
        vad_config cfg;
        cfg.Nalfa = 0.95;       //Modificamos algunos parámetros
        cfg.SNRalfa = 0.95;
 
        //Inicializamos el objeto
        vad_object.Reset(cfg, 80);

Este método de construir puede ser útil si queremos aplicar el VAD a varios archivos diferentes o con diferentes configuraciones. El VAD mantiene una serie de memorias internas que es necesario resetear si pasamos a procesar otro archivo o queremos procesar el mismo otra vez, lo cual es precisamente lo que hace Reset():

        vad vad_object;         //Constructor por defecto
 
        //Hacemos cositas por el camino
        vad_config cfg;
        cfg.Nalfa = 0.95;       //Modificamos algunos parámetros
        cfg.SNRalfa = 0.95;
 
        for (int i = 0; i < NumFicheros; ++i)
        {
            //Hay que resetear el VAD para cada fichero
            vad_object.Reset((cfg, 80, XFFT_WIN_BLACK);     //Y esta vez, con ventena personalizada
 
            //Abrir ficheros, tomar tramas, aplicar el VAD....
        }

Nota:: Si se llama a Reset() en medio de procesar un archivo, se tendrán unos bonitos problemas. Mejor no lo hagas.

Lo único importante es recordar que un objeto construido por el constructor por defecto NO ESTÁ INICIALIZADO, y por tanto, es inutil. O se utiliza el constructor inicializador o se llama a Reset().

Modelado de ruido

El modelado de ruido es relativamente sencillo. Tomamos una serie de tramas para las que SABEMOS que no hay voz, sólo ruido, y se las damos al sistema para que haga el modelado. Durante este modelado se calculan el espectro medio y la potencia de ruido.

Para ello se ha de utilizar la función NoiseInit(). En lugar de darle al objeto todas las tramas de inicialización de golpe, se las damos una a una, llamando varias veces a esta función:

        vad vad_object;
 
        //Inicialización y otras cosas
        ...
 
        //noise_frame_number es el número de tramas que usaremos para inicializar el ruido
        int noise_frame_number = GetNoiseFrameNumber()
        for (int i = 0; i = noise_frame_number; ++i)
        {
            //Tomamos la trama y se la damos al sistema
            double* noise_frame = GetNoiseFrame(i);
            vad_object.NoiseInit(noise_frame);
        }
        //Y ya está

Aunque no hay ninguna condición, se recomienda que la inicialización del ruido se haga con unas 10 a 20 tramas, para tener una estimación bastante robusta. Como regla general se considera que 15 están bien.

Estas tramas de inicialización pueden conseguirse mediante un pre-procesado (haciendo un VAD rápido y cutre por potencia, por ejemplo, y cortando a un cierto umbral) o suponer que las primeras tramas de la señal no contienen voz y usar esas.

Nota:: Antes de empezar a utilizar el VAD es necesario hacer esta inicialización. Si no se hace, funcionará fatal. No creo que de errores, pero los resultados serán un desastre.

Inicializacion del buffer LTSE

Como ya se ha explicado, el algoritmo mantiene un buffer de más menos N tramas alrededor de la actual. Esto tiene dos implicaciones directas:

La trama para la cual se está dando la decisión NO ES LA TRAMA QUE SE ACABA DE LEER DEL ARCHIVO DE AUDIO. La decisión se da siempre para N tramas anteriores.
Es necesario llenar el buffer LTSE al menos hasta la mitad para empezar a recuperar resultados.

Dicho de otra forma, si tomamos un archivo de audio y en un momento dado estamos leyendo la trama i-ésima (i=1,...,NSamples), y se la pasamos al VAD (mediante doVAD()), el resultado devuelto es la decisión para la trama i-N.

Si ahora suponemos que i < N, entonces estará devolviendo el resultado para una trama i-N <= 0, lo cual no existe. Por lo tanto, debemos llenar el buffer con N tramas antes de poder recuperar la primera decisión. Las primeras N veces que se llame a doVAD(), el sistema no hace nada más que poblar el buffer, y la función siempre devuelve SILENCIO. A partir de ahí empieza a devolver resultados.

El tamaño completo del buffer es 2N+1, y viene dado por vad_config::LTWindowLen. Este valor DEBE SER IMPAR!!!!! (para poder tener una ventana centrada en la trama actual)

        vad_config cfg;
        cfg.LTWindowLen = 15    //Debe ser impar
        vad vad_object (cfg, 80);
 
        //Inicialización del ruido
        ...
 
        for (int i = 0; i < (cfg.LTWindowLen-1)/2; ++i)
        {
            //Tomamos la trama y se la damos al sistema
            double* frame = GetFrame(i);
            vad_object.doVAD(frame);    //Descartamos el resultado, no sirve para nada
        }
 
        //Y ya podemos empezar
        for (; i < NFrames; ++i)
        {
            //Tomamos la trama y se la damos al sistema
            double* frame = GetFrame(i);
            //Recuerda que el VAD estimado no es el que se corresponde con la trama actual
            vad[i-(cfg.LTWindowLen-1)/2] = vad_object.doVAD(frame);
        }

Umbral adaptativo

Como ya se ha indicado, el umbral de LTSD varía según la SNR estimada. Esta variación es lineal: a mayor SNR, mayor es el umbral. Pero existen unos límites de saturación.

Si SNR < cfg.SNR0 entonces $\gamma$ = cfg.gamma0
Si SNR > cfg.SNR1 entonces $\gamma$ = cfg.gamma1
En cualquier otro caso, $\gamma$ toma un valor lineal entre esos puntos.

Además, para permitir personalizar el punto de trabajo, se permite aplicar un offset a la LTSD (configurado mediante la opción vad_config::offset). Valores positivos del offset hacen que se favorezca la decisión VOZ. Valores negativos hacen que se tienda más a la decisión SILENCIO. Con esto es posible modificar el comportamiento del sistema según si es más importante que no haya tramas de silencio clasificadas como voz o tramas de voz clasificadas como silencio.

Adaptación del ruido

El espectro del ruido, potencia de ruido y potencia de la señal se van adaptando a medida que las tramas se van clasificando como VOZ o SILENCIO. Esta adaptación viene controlada por varias opciones de vad_config.

Cuando una trama se clasifica como VOZ, se toman cfg::ActWindowLen tramas anteriores a ella y se calcula la potencia media de señal en estas tramas. La potencia de señal se actualiza como:

        //Promediamos la potencia de cfg::ActWindowLen tramas anteriores
        double SpowAct = GetMeanPow(cfg.ActWindowLen);
 
        SignaPow = cfg.SNRalfa * SignalPow + (1-cfg.SNRalfa) * SpowAct;

Igualmente, por cada trama que se clasifica como SILENCIO, se hace algo parecido con la potencia de ruido. En este caso además se actualiza el espectro del ruido:

        //Promediamos la potencia y el espectro de cfg::ActWindowLen tramas anteriores
        double NpowAct = GetMeanPow(cfg.ActWindowLen);
        double* NspecAct = GetMeanSpectrum(cfg.ActWindowLen);
 
        NoisePow = cfg.Nalfa * NoisePow + (1-cfg.Nalfa) * NpowAct;
        for (int i = 0; i < Nfft; ++i)
            NoiseSpec[i] = cfg.Nalfa * NoiseSpec[i] + (1-cfg.Nalfa) * NspecAct[i];

Handover

El handover es una técnica para retrasar el paso de la decisión VOZ a la decisión SILENCIO. Su origen está en los sistemas de reconocimiento automático del habla, donde es muy importante que no haya tramas de voz clasificadas como silencio, para no perder información. Para ello, cuando hay una serie de tramas clasificadas como silencio, y de pronto llega una que se clasifica como voz, la decisión de SILENCIO se mantiene durante unas cuantas tramas de forma 'artificial'. Si todas esas tramas se clasifican como SILENCIO, entonces se realiza la transición y se empiezan a generar decisiones de SILENCIO.

El handover viene controlado por la opción cad_config::Handover.

Definición en la línea 397 del archivo vad.h.

Documentación del constructor y destructor

vad::vad ( ) [inline]

Antes de utilizar el objeto será necesario llamar a Reset() para inicializar los valores de configuración

Definición en la línea 459 del archivo vad.h.

vad::vad	(	const vad_config &	cfg,
		DOUBLE	snr,
		FLOAT	FrameLen,
		XFFT_WIN	WinType
	)			`[inline]`

Inicializa los valores de configuración llamando a Reset()

Definición en la línea 468 del archivo vad.h.

vad::vad	(	const vad_config &	cfg,
		DOUBLE	snr,
		FLOAT	FrameLen
	)			`[inline]`

Inicializa los valores de configuración llamando a Reset() Utiliza la ventana por defecto (ver Reset())

Definición en la línea 479 del archivo vad.h.

vad::~vad ( ) [inline]

Definición en la línea 486 del archivo vad.h.

Documentación de las funciones miembro

bool vad::Reset	(	const vad_config &	cfg,
		DOUBLE	snr,
		FLOAT	FrameLen,
		XFFT_WIN	WinType = `XFFT_WIN_HAMM`
	)

Es la verdadera encargada de inicializar el objeto. Una llamada a esta función resetea completamente el objeto, es decir, se pierden los buffers internos, la memoria, el modelado del ruido... y nos deja un objeto como recién construido, en blanco, listo para usar.

Es muy útil en dos casos:

Si se ha utilizado el constructor por defecto, permite inicializar el objeto antes de usarlo. En caso contrario, el objeto no está listo para ser utilizado.

Si se quiere re-utilizar el mismo objeto para aplicar el VAD en otra señal, permite borrar toda la memoria y empezar de cero.

Además, una llamada a esta función es la única forma de cambiar el tamaño de la ventana de trama y el tamaño de la ventana LTSE. Esto es así porque estos dos valores están fuertemente relacionados con los buffers internos y la memoria FFT, y en caso de cambiarlos, el historial de FFT sería totalmente inutil, dejando el objeto en un estado incoherente.

El resto de los parámetros puede modificarse mediante la función get apropiada.

Devuelve:: false si ha habido errores en el reseteo
true si todo ha ido bien

Definición en la línea 48 del archivo vad.cpp.

void vad::NoiseInit ( pDOUBLE frame )

La trama que se le pasa a esta función se utiliza para la inicialización del ruido. Antes de utilizar el objeto, es necesario llamar a esta función varias veces con tramas de ruido, para que el sistema pueda estimar el espectro medio de ruido. Se recomienda llamar a esta función con unas 15 tramas diferentes antes de usar el objeto.

Nota:: IMPORTANTE: La inicialización del ruido debe hacerse antes de usar el objeto. Una vez que ya se ha realizado esta inicialización, NO DEBE LLAMARSE DE NUEVO. Cuando el sistema ya se encuentra procesando la señal, automáticamente se van actualizando las características del ruido. Llamar a esta funciónotra vez provocaría perder este comportamiento adaptativo. No ocurrirían errores de ejecución, pero el comportamiento del VAD no será el esperado.

Definición en la línea 130 del archivo vad.cpp.

bool vad::doVAD ( pDOUBLE frame )

Las primeras (LTWindowLen-1)/2 veces que se llame a esta función, el buffer de la ventana LTSE todavía no estará lleno hasta la mitad, por lo que no se puede calcular el VAD (se estaría calculando el VAD de una trama de índice negativo). En estos casos devuelve silencio.

Es cosa del programador tener esto en cuenta (al igual que lo es tener en cuenta que el VAD que se devuelve es el de la trama que se pasa -(LTWindowLen-1)/2).

Devuelve:: true si la trama contiene voz
false si la trama es silencio

Nota:: REPITO: El valor devuelvo por la función NO ES EL VAD de la trama que se le pasa como parámetro, sino el de la trama central de la ventana LTSE. Es decir, el de las trama que se pasó (LTWindowLen-1)/2) llamadas anteriores.

Definición en la línea 181 del archivo vad.cpp.

LONG vad::getFrameLen ( ) const [inline]

Definición en la línea 513 del archivo vad.h.

INT vad::getNfft ( ) const [inline]

será la siguiente potencia de dos de getFrameLen().

Bueno, en realidad, la mitad de la siguiente potencia de dos, ya que al ser simétrica, sólo devuelve medio espectro.

Definición en la línea 525 del archivo vad.h.

INT vad::getLTWindowLen ( ) const [inline]

Definición en la línea 532 del archivo vad.h.

bool vad::IsBufferFull ( ) const [inline]

Devuelve verdadero si el buffer ya está suficientemente lleno como para empezar a calcular cosas

Definición en la línea 542 del archivo vad.h.

DOUBLE vad::getNoisePow ( ) const [inline]

Definición en la línea 548 del archivo vad.h.

void vad::setNoisePow ( DOUBLE np ) [inline]

Definición en la línea 553 del archivo vad.h.

DOUBLE vad::getSignalPow ( ) const [inline]

Definición en la línea 559 del archivo vad.h.

void vad::setSignalPow ( DOUBLE sp ) [inline]

Definición en la línea 564 del archivo vad.h.

DOUBLE vad::getSNR ( ) const [inline]

Definición en la línea 570 del archivo vad.h.

void vad::setSNR ( DOUBLE snr ) [inline]

Puede servir para inicializar la SNR inicial si todavía no se conocía cuando se ha hecho el Reset()

Definición en la línea 579 del archivo vad.h.

DOUBLE vad::getSNR0 ( ) const [inline]

Definición en la línea 585 del archivo vad.h.

void vad::setSNR0 ( DOUBLE snr0 ) [inline]

Definición en la línea 590 del archivo vad.h.

DOUBLE vad::getSNR1 ( ) const [inline]

Definición en la línea 596 del archivo vad.h.

void vad::setSNR1 ( DOUBLE snr1 ) [inline]

Definición en la línea 601 del archivo vad.h.

DOUBLE vad::getGamma0 ( ) const [inline]

Definición en la línea 607 del archivo vad.h.

void vad::setGamma0 ( DOUBLE gamma0 ) [inline]

Definición en la línea 612 del archivo vad.h.

DOUBLE vad::getGamma1 ( ) const [inline]

Definición en la línea 618 del archivo vad.h.

void vad::setGamma1 ( DOUBLE gamma1 ) [inline]

Definición en la línea 623 del archivo vad.h.

INT vad::getActWindowLen ( ) const [inline]

Definición en la línea 629 del archivo vad.h.

void vad::setActWindowLen ( INT ActWindowLen ) [inline]

Definición en la línea 634 del archivo vad.h.

FLOAT vad::getNalfa ( ) const [inline]

Definición en la línea 641 del archivo vad.h.

void vad::setNalfa ( FLOAT Nalfa ) [inline]

Definición en la línea 646 del archivo vad.h.

FLOAT vad::getSNRalfa ( ) const [inline]

Definición en la línea 652 del archivo vad.h.

void vad::setSNRalfa ( FLOAT SNRalfa ) [inline]

Definición en la línea 657 del archivo vad.h.

DOUBLE vad::getOffset ( ) const [inline]

Definición en la línea 663 del archivo vad.h.

void vad::setOffset ( DOUBLE offset ) [inline]

Definición en la línea 668 del archivo vad.h.

INT vad::getHandover ( ) const [inline]

Definición en la línea 674 del archivo vad.h.

void vad::setHandover ( INT Handover ) [inline]

Definición en la línea 679 del archivo vad.h.

void vad::Destruct ( ) [protected]

Toda la funcionalidad del destructor está pasada a esta función

Definición en la línea 229 del archivo vad.cpp.

DOUBLE vad::Gamma ( ) const [protected]

Definición en la línea 239 del archivo vad.cpp.

void vad::ActualizeSignal ( ) [protected]

Definición en la línea 250 del archivo vad.cpp.

void vad::ActualizeNoise ( ) [protected]

Definición en la línea 273 del archivo vad.cpp.

void vad::AddToBuffer ( pDOUBLE frame ) [protected]

Definición en la línea 306 del archivo vad.cpp.

void vad::LTSE ( ) [protected]

Definición en la línea 318 del archivo vad.cpp.

DOUBLE vad::LTSD ( ) const [protected]

Definición en la línea 336 del archivo vad.cpp.

Documentación de los campos

LONG vad::m_FrameLen [protected]

Definición en la línea 723 del archivo vad.h.

XFFT_WIN vad::m_WinType [protected]

Definición en la línea 724 del archivo vad.h.

pRFFT vad::m_fftObject [protected]

Definición en la línea 725 del archivo vad.h.

INT vad::m_Nfft [protected]

Definición en la línea 726 del archivo vad.h.

buffer2D vad::m_memFFT [protected]

Definición en la línea 727 del archivo vad.h.

INT vad::m_bufferedFrames [protected]

Definición en la línea 729 del archivo vad.h.

pDOUBLE vad::m_NoiseFFT [protected]

Definición en la línea 735 del archivo vad.h.

INT vad::m_NoiseInitFrames [protected]

Definición en la línea 736 del archivo vad.h.

DOUBLE vad::m_NoisePow [protected]

Definición en la línea 737 del archivo vad.h.

DOUBLE vad::m_SignalPow [protected]

Definición en la línea 738 del archivo vad.h.

DOUBLE vad::m_SNR [protected]

Definición en la línea 739 del archivo vad.h.

DOUBLE vad::m_SNR0 [protected]

Definición en la línea 740 del archivo vad.h.

DOUBLE vad::m_SNR1 [protected]

Definición en la línea 741 del archivo vad.h.

INT vad::m_ActWindowLen [protected]

Definición en la línea 742 del archivo vad.h.

FLOAT vad::m_Nalfa [protected]

Definición en la línea 743 del archivo vad.h.

FLOAT vad::m_SNRalfa [protected]

Definición en la línea 744 del archivo vad.h.

pDOUBLE vad::m_NoiseFFTAct [protected]

Definición en la línea 745 del archivo vad.h.

INT vad::m_LTWindowLen [protected]

Definición en la línea 752 del archivo vad.h.

DOUBLE vad::m_gamma0 [protected]

Definición en la línea 753 del archivo vad.h.

DOUBLE vad::m_gamma1 [protected]

Definición en la línea 754 del archivo vad.h.

INT vad::m_Handover [protected]

Definición en la línea 755 del archivo vad.h.

LONG vad::m_NumSil [protected]

Definición en la línea 756 del archivo vad.h.

LONG vad::m_NumVoice [protected]

Definición en la línea 757 del archivo vad.h.

LONG vad::m_HoSil [protected]

Definición en la línea 758 del archivo vad.h.

DOUBLE vad::m_offset [protected]

Definición en la línea 759 del archivo vad.h.

pDOUBLE vad::m_LTSE [protected]

Definición en la línea 761 del archivo vad.h.

La documentación para esta clase fue generada a partir de los siguientes ficheros: