sistema de recluta de audio para bases de...

FACULTAD DE INFORMÁTICA UNIVERSIDAD POLITÉCNICA DE MADRID

UNIVERSIDAD POLITECNICA DE MADRID FACULTAD DE INFORMÁTICA

TRABAJO FIN DE CARRERA

SISTEMA DE RECLUTA DE AUDIO PARA BASES DE DATOS DE VOZ

AUTOR: ANTONIO SANTOS CALZADA TUTOR: RAFAEL MATÍNEZ OLALLA

Sistema de Recluta de Audio para Bases de Datos de Voz

- i -

Índice de contenidos

AGRADECIMIENTOS ............................................................................................................. iv

RESUMEN................................................................................................................................... v

ABSTRACT ................................................................................................................................ vi

1. INTRODUCCIÓN ........................................................................................................... - 1 -

2. OBJETIVOS ..................................................................................................................... - 2 -

3. ESTADO DEL ARTE ...................................................................................................... - 4 -

3.1. CARACTERÍSTICAS DEL SONIDO ................................................................................... - 4 -

3.2. FICHEROS WAV ............................................................................................................ - 6 -

3.3. API MULTIMEDIA DE WINDOWS ................................................................................. - 10 -

3.4. CAPTURA CON DOBLE BUFFER .................................................................................... - 15 -

4. PROYECTO HESPERIA.............................................................................................. - 21 -

5. DESCRIPCIÓN DEL PRODUCTO ............................................................................. - 25 -

5.1. VISIÓN GENERAL ......................................................................................................... - 25 -

5.2. VENTAJAS QUE OFRECE .............................................................................................. - 33 -

6. ASPECTOS TÉCNICOS ............................................................................................... - 36 -

6.1. ELECCIÓN DEL LENGUAJE........................................................................................... - 36 -

6.2. CARACTERÍSTICAS DE .NET ....................................................................................... - 38 -

6.2.1. ¿QUÉ ES .NET?........................................................................................................... - 38 -

6.2.2. INTEROPERABILIDAD ENTRE .NET Y EL API DE WINDOWS ....................................... - 40 -

6.3. MANEJO DE POWERPOINT MEDIANTE CÓDIGO ......................................................... - 43 -


- ii -

6.4. EVOLUCIÓN Y OPTIMIZACIÓN DE LA APLICACIÓN ..................................................... - 45 -

6.4.1. INTERFAZ GRÁFICA ..................................................................................................... - 45 -

6.4.2. MANEJO DE FICHEROS ................................................................................................ - 51 -

6.4.3. COMPROBACIÓN DE LOS NIVELES DE GRABACIÓN ..................................................... - 52 -

6.4.4. EL API DE CAPTURA Y WINDOWS VISTA ................................................................... - 53 -

6.4.5. MEDICIÓN DE TIEMPOS ............................................................................................... - 56 -

6.4.6. DIBUJADO DE LA ONDA DE SONIDO ............................................................................ - 57 -

6.4.6.1. Pintado en Windows ............................................................................................... - 58 -

6.4.6.2. Problema: tamaño de la imagen a pintar................................................................. - 59 -

6.4.6.3. Reducción de la profundidad de bits por pixel ....................................................... - 60 -

6.4.6.4. División de la imagen en varias .............................................................................. - 60 -

6.4.6.5. Menos llamadas de pintado .................................................................................... - 61 -

6.4.6.6. Configuración del buffer de captura ....................................................................... - 62 -

6.4.6.7. Sincronización de los hilos de captura.................................................................... - 63 -

6.4.7. MANEJO DE LA PRESENTACIÓN POWERPOINT ............................................................ - 64 -

6.4.7.1. Frases personales de locutor ................................................................................... - 64 -

6.4.7.2. Visualización de la presentación en tiempo real ..................................................... - 66 -

6.4.7.3. Selección automática del ejercicio.......................................................................... - 68 -

7. DISEÑO DE CLASES ................................................................................................... - 69 -

8. CONCLUSIONES Y TRABAJO FUTURO ............................................................... - 77 -

9. REFERENCIAS BIBLIOGRÁFICAS ........................................................................ - 83 -

10. ANEXO – MANUAL DE USUARIO ......................................................................... - 86 -


- iii -

Índice de figuras

Figura 3.1. Estructura del formato WAV ..................................................................... - 8 -

Figura 3.2. Estructura detallada de un fichero WAV ................................................... - 9 -

Figura 4.1. Esquema del reconocedor biométrico de Hesperia .................................. - 22 -

Figura 4.2. Aplicación de seguridad para el sistema Android ................................... - 23 -

Figura 4.3. Reconocedor de emociones del proyecto Hesperia ................................. - 24 -

Figura 5.1. Ventana principal de Sesión de Grabación .............................................. - 25 -

Figura 5.2. Selección de locutor y sesión ................................................................... - 26 -

Figura 5.3. Ventana principal con sesión seleccionada.............................................. - 28 -

Figura 5.4. Ventana de configuración de captura de audio ........................................ - 29 -

Figura 5.5. Ventana de Sesión de Grabación durante una grabación......................... - 32 -

Figura 5.6. Esquema de realización de ejercicios antes de Sesión de Grabación ...... - 34 -

Figura 6.1. Diagrama interno de CLR ........................................................................ - 39 -

Figura 6.2. Comparación entre la primera interfaz y la definitiva ............................. - 46 -

Figura 6.3. Botones principales de la aplicación........................................................ - 48 -

Figura 6.4. Comparación entre las miniaturas de PowerPoint antigua y nueva ......... - 49 -

Figura 6.5. Comparación entre el modelo de barras y gráfica ................................... - 50 -

Figura 6.6. División del bitmap de pintado en bitmaps más pequeños ...................... - 61 -

Figura 6.7. Ventana de edición de frases personales ................................................. - 65 -

Figura 6.8. Transparencia con frase personalizada .................................................... - 66 -

Figura 7.1. Diagrama de clases de Sesión de Grabación ........................................... - 69 -

Figura 8.1. Uso interactivo de la presentación de PowerPoint .................................. - 78 -

Figura 8.2. Equipo para la realización de sesiones con dispositivos portátiles ......... - 81 -


- iv -

AGRADECIMIENTOS

Y finalmente, tras todo este tiempo, que la verdad, no se me ha hecho nada largo,

me hallo escribiendo lo que es la culminación de la carrera universitaria. O tal vez no,

nunca se sabe qué nos depara el destino. De todas formas es el momento de agradecer a

todos aquellos que me han aportado algo en este interesante paseo que ha sido la

Facultad de Informática.

Lo primero agradecer a mi familia por soportarme todo este tiempo. A mis amigos,

por ser mis amigos. A los buenos profesores, que no podré dejar nunca de agradecer su

trabajo, y a los no tan buenos, porque siempre tenemos algo que aprender de todo el

mundo. Al DATSI en concreto por haberme dejado hacer mi proyecto de Sistemas

Informáticos y más adelante mi trabajo fin de carrera. A Rafael, Víctor, Pedro, Alfonso,

etc. A los compañeros del laboratorio por tener siempre ganas de ayudar a todos y reírse

con todos: Dani, Luis, Cristina, Roberto…

Y no puedo dejar de dar agradecimientos a Internet. Y qué es Internet más que las

personas que dedican su tiempo en la red. En especial a las personas que dedican su

tiempo libre a ayudar y a compartir lo que duramente han aprendido con los demás.

Como suele decirse, por amor al arte. Porque ayudan a que el conocimiento sea de

todos.

Gracias.


- v -

RESUMEN

En este documento se presenta una aplicación llamada Sesión de Grabación,

desarrollada con el fin específico de permitir realizar el proceso de recluta de audio para

la creación de bases de datos de voz. Las bases de datos de voces procedentes de

distintos tipos de locutores, resultan de gran ayuda en el desarrollo de sistemas de

reconocimiento automático de voz, al ser una base de estudio que, según sus

características como género, edad, patologías o idiomas de los locutores, permitirán

realizar reconocedores tanto de propósito específico como general.

La aplicación Sesión de Grabación permitirá capturar y clasificar de forma

automática las voces de los locutores participantes, de forma sencilla y pudiendo ser

utilizada por un solo usuario. Esta aplicación surge como una evolución de los métodos

anteriores usados para el mismo fin.

En el tercer capítulo de este documento se describe el estado del arte, información

básica para entender los aspectos que influyen en el tratamiento de audio digital,

específicamente en el sistema operativo Windows. En el capítulo 4 se hablará del

proyecto Hesperia en el que se encuadra la presente aplicación. En los capítulos 5, 6 y 7,

se tratará de forma más directa la aplicación, explicando sus funcionalidades, y entrando

en detalles de diseño e implementación. Finalmente en el capítulo 8 se comentarán

ciertas formas en las que podría evolucionar Sesión de Grabación en un futuro cercano.


- vi -

ABSTRACT

In this document a new application called “Sesión de Grabación” will be showed

and explained in detail. The aim of it is being able to capture audio for the creation of

databases for voice. The databases containing voices from different kind of speakers are

of great aid for the development of automatic voice recognition systems. Depending on

the characteristics of the speakers, such as their idiom, gender, age or pathology, these

databases can become the base of study for both general and specific purpose voice

recognizers.

The application “Sesión de Grabación” allows the user to automatically capture and

classify the voice of the participant speakers, in an easy way and only needing one user

to control it. This is an evolution of previous and less efficient methods for the same

purpose.

On the third chapter in this document it is described the state of the art, some basic

information needed to understand the aspects that affect the digital audio management,

with some details being specific for the Windows operating system. On chapter 4, I will

talk about the Hesperia project, in which this application is contained. On chapters 5, 6

and 7, the application “Sesión de Grabación” will be explained more specifically,

showing its functionalities and the design and development aspects. Finally on chapter

8, some of the future possible evolutions and improvements for the application will be

discussed.

Sistema de Recluta de Audio para Bases de Datos de Voz INTRODUCCIÓN

- 1 -

1. INTRODUCCIÓN

Hoy en día en la mayoría de los aspectos de la vida, las personas buscan la

eficiencia, el poder hacer más teniendo al mismo tiempo el mínimo coste posible en eso

que hacen. Esta búsqueda de la optimización y el aprovechamiento de los recursos que

se poseen se convierten en una obligación cuando de lo que hablamos es un trabajo, una

investigación o cualquier otra cosa que involucre un presupuesto.

Fruto de esta necesidad, aunque también de otras igualmente importantes como el

aprendizaje y la experimentación, se ha creado la aplicación que en este trabajo se

presenta. Una herramienta de ayuda en la realización de sesiones de captura de voz de

diferentes locutores.

Más adelante se explicará al detalle en qué consisten estas sesiones de captura de

voz, por qué se quiere capturar esta voz, hablando así del proyecto Hesperia, y

sobretodo de por qué es necesaria o al menos de de gran ayuda un aumento de la

eficiencia en todo este proceso.

Así mismo se hablará de las tecnologías involucradas en la creación de este

software, el porqué de éstas, su aplicación en un caso real y diferentes problemas a los

que se ha tenido que hacer frente en la realización.

Sistema de Recluta de Audio para Bases de Datos de Voz OBJETIVOS

- 2 -

2. OBJETIVOS

Aunque de forma general ya se ha hablado en parte de uno de los objetivos de este

proyecto, a continuación se detallarán aquellos objetivos que se pretendían alcanzar con

este trabajo.

Objetivo general

Realización de una aplicación que permita completar a una sola persona todo

el proceso de captura de voz en una sesión de grabación.

Objetivos concretos de la aplicación

Capacidad de grabación de un dispositivo de sonido MOTU Traveller

conectado mediante puerto FireWire.

Grabación de cuatro canales en un fichero distinto cada uno.

Automatización en la generación de los ficheros de audio.

Comprobación de los niveles de entrada por micrófono.

Visualización gráfica de los cuatro canales de entrada.

Manejo de una presentación PowerPoint desde la misma aplicación,

mostrándola en una pantalla secundaria.

Visualización de la presentación desde la aplicación.

Sistema de Recluta de Audio para Bases de Datos de Voz OBJETIVOS

- 3 -

Sincronización entre lo grabado y la parte actual de la presentación.

Comprobación del tiempo de grabación.

Capacidad de reproducción de lo grabado.

Gestión de grabaciones propias de cada locutor.

Junto con estos requisitos funcionales de la aplicación se encuentra la necesidad de

que todo esté disponible para usarse bajo un sistema operativo Windows Vista, que será

el usado durante las sesiones de captura.

Sistema de Recluta de Audio para Bases de Datos de Voz ESTADO DEL ARTE

- 4 -

3. ESTADO DEL ARTE

3.1. Características del sonido

En el tratamiento computacional que se realiza sobre el sonido [1] mediante

funciones de un lenguaje de programación, veremos a este sonido como una secuencia

de muestras, cada una de ellas siendo un valor entero. El número de muestras que

tengamos que procesar y las propiedades de las mismas van determinadas por unas

características básicas que constituyen el formato de sonido, y que son:

La frecuencia de muestreo. Indica la cantidad de muestras de sonido que

encontraremos en un intervalo de 1 segundo. Los valores típicos que suele

adoptar son 8000, 11025, 22050, 44100 o 48000, aunque podrían ser mayores.

Para una calidad buena de tipo CD se usa por lo general una frecuencia de 44100

muestras por segundo, aunque en ocasiones con el fin de tener aún mayor

calidad de sonido, como podría ser en una película, se utilizan valores mayores

como 48000, o mayores en estudios profesionales.

Tamaño de la muestra. Se expresa en bits. Los tamaños típicos son 8 o 16 bits

por muestra. Cuantos más bits se usen para almacenar cada muestra, mayor será

el rango de valores que ésta pueda alcanzar, y esto se traduce en una mayor

precisión del sonido, más calidad y menor ruido de cuantificación.

En este aspecto hay que realizar algunas aclaraciones sobre los valores que

pueden adquirir las muestras. En el caso de muestras de 16 bits, el número

máximo de combinaciones que podemos tener es 65536. Cuando editamos audio

con un lenguaje de programación, vemos estas muestras como valores de 16 bits

con signo (tipo short en caso de C++), lo cual nos aporta mayor claridad en su

manejo, ya que tendremos el punto medio en el valor 0, siendo éste la


- 5 -

representación del silencio. Cuanto más alejado de 0 sea el valor de la muestra,

mayor será la intensidad del sonido, siendo el rango de -32768 a +32767.

En el caso de muestras de 8 bits, no nos vendrán dadas como valores de 8 bits

con signo sino sin signo (tipo BYTE en C++), por tanto en el rango de 0 a 255.

Para poder realizar de forma más cómoda e intuitiva su procesamiento,

querremos tenerlo centrado en el valor 0 como sucedía con las muestras de 16

bits. Para ello cada vez que procesemos una muestra de 8 bits le restaremos a su

valor 128, quedando así el rango en -128 a 127, siendo de nuevo 0 el silencio y

los valores más alejados de mayor intensidad. Tras su procesamiento y para

almacenar las muestras de este tamaño, se debe volver a sumarlas 128 para que

así sean interpretables por la tarjeta de sonido.

Como se ha visto, mayor tamaño en bits implica mayor calidad del sonido. Una

calidad como sería la de un teléfono sólo requeriría el uso de 8 bits, y 16 bits se

usarían para calidad de tipo CD. En grabaciones más profesionales podrían

llegar a usarse 24 o 32 bits por muestra.

Número de canales. Indicará el número de fuentes de las que fue grabado el

sonido en su origen, o el número de diferentes parte que posee. Cada canal del

audio puede contener una información independiente a los demás canales. Se

suele almacenar el sonido en más de un canal para así tener más información del

mismo. Cada canal podría contener la grabación de un mismo sonido realizada

con distintos micrófonos, o simplemente efectos distintos que se le quieran

añadir al sonido, ya que todos los canales pueden ser reproducidos al mismo

tiempo.

En un fichero de audio la forma en que tendremos la información de los canales

es una muestra de cada canal una a continuación de la otra. Esto es, si

tuviésemos sonido ya sea en un fichero o recién capturado de la tarjeta de

sonido, con 2 canales, tendríamos una sucesión de muestras intercaladas del


- 6 -

canal izquierdo y del canal derecho: I D I D I D I D… cada una de estas

muestras teniendo un tamaño especificado (8, 16 bits, etc.). En el caso de 4

canales, la muestras se encontrarían de esta forma: 1 2 3 4 1 2 3 4 1 2 3 4…

Se podría resumir cómo estos parámetros afectan a la calidad con dos ejemplos bien

conocidos ya mencionados:

Uso Frecuencia de

muestreo

Tamaño de la

muestra

Número de

canales

Grabación de CD 44100 Hz 16 bits 2

Conversación telefónica 8000 Hz 8 bits 1

3.2. Ficheros WAV

El formato WAV [2] es un formato estándar de Microsoft e IBM para almacenar

sonido, y se trata de uno de los formatos más populares para el almacenamiento de

audio PCM (Pulse Code Modulation) [3]. El formato WAV desciende de un tipo de

formatos llamado IFF (Interchange Format Files) creado por Electronic Arts en 1985

para facilitar la transferencia de información entre sistemas desarrollados por distintas

compañías. Microsoft e IBM, basándose en este tipo de formato IFF, crearon el RIFF

(Resource Interchange File Format) [4], siendo el WAV una aplicación de este formato

RIFF [5]. Otro ejemplo de formato RIFF sería el tan utilizado AVI para el

almacenamiento de vídeos.

Los formatos RIFF se caracterizan por estar estructurados en una serie de bloques, o

como se denominan originalmente, chunks. Cada uno de estos chunks va a tener el

siguiente formato:


- 7 -

o 4 bytes con el identificador del chunk. Es decir, 4 letras con el nombre que le

diferencia del resto, como puede ser “data” o “fmt “.

o 4 bytes indicando la longitud del chunk, sin contar la longitud del

identificador y de este campo.

o Campo de datos del chunk de tamaño variable, dependiendo de lo que deba

almacenar.

o En caso de que la longitud del chunk sea impar, un byte extra para hacerlo

par.

Los chunks de los formatos RIFF se clasifican de forma jerárquica, existiendo

chunks padre del que luego dependerán uno o varios chunks hijos. El chunk principal y

obligatorio en todos los ficheros de tipo RIFF como el formato WAV, se llama chunk

“RIFF”, y de él dependerán otros de los chunks obligatorios, como se ve en la figura

3.1.


- 8 -

Figura 3.1. Estructura del formato WAV

De forma más detallada, los chunks obligatorios de todo fichero WAV que se ven en

la figura 3.1, tienen la siguiente función:

Chunk RIFF – indica que el fichero tiene una estructura RIFF, y que a

continuación encontraremos el resto de chunks necesarios en este tipo de ficheros.

Tras la cabecera encontramos el identificador del tipo de fichero RIFF que es, en

este caso “WAVE” indicando que es un fichero de audio PCM.

o Chunk de formato “fmt “ – contiene toda la información básica de las

características de sonido que posee este fichero, como la frecuencia de


- 9 -

muestreo, el tamaño de muestra, el número de canales, y otros datos que se

calculan a través de estos tres parámetros.

o Chunk de datos “data” – contiene la secuencia de todas las muestras que

forman el fichero de sonido, en la forma que se explicó al comienzo de este

apartado. Además, de este chunk se puede extraer la información del tamaño

en bytes que ocupan todas las muestras de sonido, dato de gran utilidad para

las aplicaciones que manipulen este tipo de de ficheros.

En la figura 3.2 se puede observar con mucho más detalle esta estructura de un

fichero WAV con el tamaño que ocupa cada una de sus partes.

Figura 3.2. Estructura detallada de un fichero WAV

Una de las características interesantes de los formatos de tipo RIFF como el WAV

es su flexibilidad con el uso de los chunks. A parte de los tres chunks obligatorios que


- 10 -

ya se han visto, a partir de ahí, un software de edición de sonido podría incorporar todos

los chunks propios que desease, conteniendo cualquier tipo de información. Un ejemplo

sería un chunk que almacenase la letra de la canción que contiene el fichero, o un chunk

con las notas para tocar con guitarra la canción, o un chunk que contuviese la biografía

del autor del fichero. Para poder hacer uso de estos chunks no estándar, la aplicación

que manejase el fichero tendría que conocer sus identificadores y forma de uso.

3.3. API multimedia de Windows

Para la programación de aplicaciones que manejen cualquier dispositivo o fichero

que contenga o esté relacionado con un uso multimedia, Microsoft proporciona una gran

cantidad de funciones básicas. Podemos encontrar funciones multimedia para acceder al

mezclador de Windows, para reproducir o grabar sonido, ya sea con un nivel de detalle

muy bajo o no tan bajo dependiendo de nuestras necesidades. Podemos ver

característica de vídeos o manejar dispositivos para juegos.

Todas estas funciones están accesibles haciendo uso de la cabecera

“MMSYSTEM.H” [6], y más concretamente estando implementadas en la biblioteca

dinámica “winmm.dll”. En la aplicación que aquí se describe, el contacto con el sistema

multimedia viene principalmente de dos necesidades, la de poder capturar sonido

proveniente de los micrófonos de un dispositivo conectado al PC, y la de poder

finalmente almacenar el sonido capturado en formato WAV para así poder ser

almacenado sin pérdida de calidad a diferencia de otros formatos como el MP3 o el

OGG, y reproducirlo a voluntad en cualquier equipo. Aunque un tercer uso del sistema

multimedia fue contemplado en un principio, que fue el uso del mezclador de Windows

para establecer los niveles de volumen de entrada, finalmente fue desestimado y

sustituido por otro método más útil como será descrito en la evolución de la aplicación.


- 11 -

A continuación se explican las funciones usadas para la captura de sonido. Estas

funciones son válidas para el uso de cualquier dispositivo estándar que pueda reconocer

Windows como una fuente de sonido. Dentro de las funciones multimedia se han

utilizado las de más bajo nivel, ya que son las que permiten un mayor acercamiento a

las características del audio y a la manipulación a nivel de cada una de sus muestras de

sonido.

waveInOpen – seleccionando un dispositivo de grabación del PC, lo abre para

permitir comenzar a usarlo. Es la primera función que debe ser llamada antes de

realizar cualquier otra operación de captura.

waveInClose – la operación complementaria a waveInOpen. Una vez se haya

terminado de utilizar el dispositivo de captura debe cerrarse para que pueda ser

utilizado por otras aplicaciones y liberar recursos.

waveInGetNumDevs – esta función devuelve el número de dispositivos de

captura de sonido reconocidos por Windows. Resulta útil para poder listarlos y

seleccionar los que interesen.

waveInGetErrorText – en caso de haberse producido algún error relacionado

con la captura de sonido, esta función devuelve un mensaje de texto indicando con

detalle qué es lo que ha ocurrido. Permite dar información útil al usuario en caso de

que algo imprevisto ocurra.

waveInPrepareHeader – tras haber creado una estructura de datos que pueda

ser utilizada por el sistema de captura para almacenar audio en ella, se la pasaremos

a esta función para que la deje en un estado adecuado para que sea perfectamente

interpretable por la tarjeta de sonido. Si utilizamos más de un buffer para la

grabación, deberemos usar esta función con tantas estructuras como buffers usemos.


- 12 -

waveInUnprepareHeader – la función complementaria de la anterior. Limpia

la estructura de almacenamiento de audio usada por el dispositivo. Debe ser llamada

por cada buffer que usemos una vez vayan a dejar de usarse los buffer al finalizar la

grabación.

waveInAddBuffer – una vez hemos preparado un buffer con

waveInPrepareHeader, usaremos esta función para mandarle el buffer al

dispositivo, e inmediatamente éste comenzará a grabar rellenando el buffer pasado.

Cuando el dispositivo haya terminado de llenar el buffer con muestras de sonido,

devolverá el buffer a la aplicación.

waveInStart – tras llamar a esta función, el dispositivo abierto para la captura

comienza a capturar. Para que esto sea posible, el dispositivo debe haber recibido

algún buffer de captura preparado con la función waveInPrepareHeader, con

la función waveInAddBuffer. Aunque no reciba nuevos buffer de captura, el

dispositivo sigue capturando, aunque sin almacenar lo capturado en caso de no tener

buffers, hasta que se le notifique que se debe parar.

waveInReset – esta función para la grabación y pone el tiempo de grabación a

cero. Además devuelve instantáneamente los buffers que estén siendo usados para

capturar a la aplicación con lo que contuviesen en ese momento.

waveInGetDevCaps – devuelve una estructura conteniendo información de las

características de un determinado dispositivo de captura reconocido por Windows.

De esta forma podremos saber cuántos canales de grabación admite, el nombre del

dispositivo y otros datos de interés.

Aparte de capturar audio de uno o varios dispositivos, como ya se ha dicho este

sonido debe finalmente ser almacenado en uno o varios ficheros de tipo WAV [7].


- 13 -

Como se ha explicado en el apartado anterior, estos no son más que ficheros con unos

determinados requisitos en su estructura interna, y por tanto conociendo ésta podríamos

crear estos ficheros como si de un fichero normal y corriente se tratase, escribiendo el

número exacto de bytes en cada lugar que correspondiese. Esto sería perfectamente

posible, y muchas aplicaciones que no pueden tener acceso a las funciones del API de

Windows lo hacen, pero ese no es nuestro caso, y por tanto se hace uso de unas

funciones que permiten despreocuparse de los detalles internos de este tipo de formatos

RIFF.

mmioOpen - esta función nos permite abrir o crear un fichero WAV. A la hora de

abrirlo podremos elegir hacerlo para lectura, escritura o para ambas cosas. Con esta

función se podrá comprobar si existe o no un determinado fichero o incluso

borrarlo. Cuando se deje de usar un fichero abierto con esta función, su manejador

debe ser cerrado mediante su función complementaria mmioClose.

mmioClose - cierra un fichero multimedia abierto con mmioOpen, dejándolo

listo para poder acceder a él por cualquier aplicación.

mmioRead - lee de un fichero multimedia una cierta cantidad de bytes a un

buffer. Esta función finalmente no ha sido necesaria en esta aplicación, ya que no se

necesita abrir ningún fichero WAV para lectura, únicamente se crean y se escribe en

ellos. Al reproducir un fichero WAV se podrá hacer uso de una función de más alto

nivel que no requiera leer sus muestras una a una.

mmioWrite - escribe en un fichero multimedia una determinada cantidad de

bytes leídos de un buffer. La posición actual del fichero se incrementa en ese

número de bytes, por lo que siguientes lecturas o escrituras se realizarán desde el

final del fichero.


- 14 -

Como ya se ha explicado, los ficheros de sonido WAV tienen una estructura de

bloques o chunks, y para poder acceder a la información que nos proporciona cada uno

de los chunks tendremos unas funciones específicas. Para poder utilizarlas deberemos

haber abierto el fichero de audio con mmioOpen previamente.

mmioAscend - nos servirá para ascender en la estructura de chunks al chunk

padre del que nos encontramos. Usaremos un puntero a una estructura que contiene

la información del chunk que vamos a ascender para que así reconozca dónde

queremos llegar.

mmioCreateChunk - creará un nuevo chunk en la posición del fichero donde

nos encontremos. Tendremos un puntero a una estructura que contendrá la

información del chunk cuando sea creado. Uno de los flags que se usarán será

MMIO_CREATERIFF cuando se quiera crear el chunk principal RIFF de todo

fichero WAV. En el resto de los casos no se usarán flags por norma general.

mmioFOURCC - antes de llamar a la función mmioCreateChunk, se debe

preparar la estructura que almacenará los datos del chunk. Para rellenar

correctamente el campo identificador del chunk a ser creado, esta función convertirá

cuatro caracteres que le pasemos, que podrían ser “WAVE”, “fmt “, etc., en un

string válido para la función mmioCreateChunk.

Para poder crear correctamente un fichero WAV que sea reconocido por cualquier

aplicación que haga uso de estos, habrá que seguir unos pasos usando las funciones

recientemente explicadas [8]:

1) mmioOpen. Creamos un fichero en la ruta deseada con extensión .WAV.


- 15 -

2) mmioCreateChunk. Usamos el flag MMIO_CREATERIFF para crear el

chunk padre principal RIFF.

3) mmioCreateChunk. Creamos el chunk de formato, hijo del chunk

principal. La estructura que se le habrá pasado a esta función para crear el

chunk tendrá como identificador la cadena “fmt “.

4) mmioWrite. Tras la cabecera del chunk de formato escribimos en el

fichero el bloque con las características del audio que previamente creamos.

5) mmioAscend. Ascendemos del chunk de formato.

6) mmioCreateChunk. Al mismo nivel que el chunk de formato creamos el

chunk de datos. Su identificador será “data”, y en el campo del tamaño en la

estructura del chunk pondremos el número de bytes que ocupa el vector de

muestras del audio que hemos grabado.

7) mmioWrite. Tras la cabecera del chunk de datos escribimos el vector de

muestras del audio. Escribiremos tantos bytes como ocupe este vector.

8) mmioAscend. Ascendemos del chunk de datos.

9) mmioAscend. Ascendemos de nuevo hasta colocarnos en el nivel más alto

de la jerarquía del chunks.

10) mmioClose. Cerramos el fichero WAV, quedando listo para su

reproducción o posterior tratamiento.

3.4. Captura con doble buffer

Una vez conocidas las funciones que nos proporciona Windows para poder realizar

captura de sonido desde un dispositivo estándar, observamos que la secuencia típica de

llamadas para conseguirlo sería la siguiente [9] [10]:

- waveInOpen: abrir el dispositivo que se desee.

- waveInPrepareHeader: preparamos el buffer de captura.


- 16 -

- waveInAddBuffer: le pasamos el buffer de captura al dispositivo.

- waveInStart: comenzamos la captura.

Cuando termine la captura se nos devolverá el buffer, lo procesamos, y a

continuación:

- waveInUnprepareHeader: liberamos la estructura del buffer.

- waveInClose: liberamos el dispositivo de captura.

En este esquema básico de grabación se pueden observar algunas carencias que en la

mayoría de las aplicaciones que realicen captura de sonido serían inadmisibles. Por un

lado vemos que cuando el buffer de captura se llene con el audio capturado, será

retornado a la aplicación y la captura se habrá acabado. Esto supone una gran

limitación, ya que sólo podremos grabar un fragmento de un tiempo limitado. Este

tiempo dependerá de las características del formato de captura (frecuencia de muestreo,

etc.) y del tamaño del buffer de captura. Este método aunque sencillo nos quita toda la

flexibilidad de la que el sistema de captura es capaz.

Uno de los requisitos de esta aplicación es que pueda capturarse una cantidad

ilimitada de audio desde los cuatro micrófonos, pudiendo interrumpirse la grabación en

cualquier momento que se desee, por lo que la solución recién vista de ninguna manera

se adapta a nuestras necesidades. En cuanto a la posibilidad de la captura ilimitada, por

supuesto existe un límite lógico que es la capacidad del disco duro de la máquina que

ejecute la aplicación. Si hay muy poco espacio libre no podremos capturar durante un

largo periodo. Por otro lado existe un límite relativo a los ficheros WAV, ya que estos

no pueden contener más de 4 GB de información por limitaciones del formato. De todas

formas, y suponiendo que las características de grabación estándar serán una frecuencia

de muestreo de 44100 mues/seg, 16 bits por muestra y un canal por fichero WAV,

podríamos teóricamente estar grabando durante algo más de 12 horas y media antes de

alcanzar el límite de los ficheros WAV, lo que nos lleva a considerar que el tamaño de

los ficheros no es una limitación para la aplicación, que por norma general no estará

más de unos pocos minutos seguidos grabando.


- 17 -

Cuando el dispositivo de captura se pone a funcionar tras la llamada a waveInStart,

como se comentó en el anterior apartado, no para de capturar hasta que se llame a

waveInReset o waveInStop (no explicada por no ser usada en la aplicación, aunque de

funcionamiento intuitivo), aunque no tenga ningún buffer de captura donde almacenar

lo grabado. Sabiendo esto se llega a la conclusión de que proporcionando más buffers a

la capturadora seguirá almacenando lo grabado de forma continua. Esto nos lleva a la

aproximación de la captura con doble buffer.

Haciendo una ligera modificación al algoritmo del comienzo de este apartado, en el

momento en que la capturadora ha terminado de llenar el primer buffer, inmediatamente

le podemos pasar otro buffer distinto para que lo que siga grabando a continuación

quede almacenado también. O incluso mejor todavía que este funcionamiento, que

podría ocasionar la pérdida de algunas muestras de sonido en el intervalo de tiempo

entre la llegada del primer buffer y el paso del segundo, sería tener una cola de buffers

en el dispositivo de captura, y en cuanto el primero se llenase, automáticamente el

dispositivo pasaría a usar el siguiente en la cola. Éste es precisamente el uso que hace

un dispositivo de captura mediante las funciones del API de Windows.

Para lograr el sistema de la cola de buffers, basta con introducirlos todos antes de

comenzar la grabación mediante las funciones conocidas waveInPrepareHeader y

waveInAddBuffer, una llamada de cada función por cada buffer que queramos encolar.

De todas formas esto solo no basta, ya que al capturar, cuando llenase el primer buffer

pasaría a usar el segundo, luego el tercero, etc., y finalmente se acabarían los buffers y

dejaría de almacenarse el sonido. Por esto tenemos que realizar una realimentación en la

cola de los buffers. Cuando la aplicación sea notificada de la llegada del primer buffer

lleno, lo procesaremos, e inmediatamente lo volveremos a encolar en la cola de buffers,

y así con todos lo que nos lleguen. De esta forma conseguimos una grabación infinita

(con los límites ya mencionados).

Para conseguir esta cola infinita de buffers de captura nos puede bastar con tener 2

buffers. Mientras nos llega uno lleno y lo procesamos, el otro se está llenando, y antes


- 18 -

de que este esté lleno por completo ya habremos encolado el anterior. Como se puede

observar, el éxito de este procedimiento depende de dos factores: el tiempo que le lleve

a la máquina procesar cada buffer, y el tiempo que tarde el dispositivo de captura en

llenar un buffer con muestras de sonido. Si el tiempo de procesamiento del buffer fuese

mayor que el de captura, tendríamos pérdidas de sonido, ya que cuando el dispositivo de

captura está esperando tener un nuevo buffer donde almacenar muestras, todavía no nos

ha dado tiempo a encolarlo por estar procesándolo.

Para solucionar este posible problema habría varias posibilidades: una sería utilizar

más buffers en la cola, así no importaría emplear algo más de tiempo en el

procesamiento de cada buffer. Otra solución sería aumentar el tamaño de cada buffer,

tardando el dispositivo de captura más tiempo en llenarlo. De todas formas, esta última

solución se podría volver en nuestra contra si el aumento del tamaño del buffer

involucrase un aún mayor tiempo de procesamiento por la mayor cantidad de muestras a

procesar, y esto dependerá únicamente del tratamiento que se haga de las muestras. Otra

solución sería mejorar el rendimiento del algoritmo encargado de procesar los buffers,

aunque esto puede no ser posible en ciertos casos.

En concreto para esta aplicación se comprobó que con el uso de únicamente 2

buffers, un tamaño de buffer de 8 KB y mejorando de distintas formas el algoritmo de

procesamiento, se podía alcanzar una grabación continua. De todas formas estos detalles

serán tratados en profundidad en el apartado de los aspectos técnicos del producto.

Con lo que ahora sabemos, el algoritmo de captura quedaría de la siguiente manera:

- waveInOpen: abrir el dispositivo que se desee.

- Por cada buffer que se desee encolar:

o waveInPrepareHeader: preparamos el buffer de captura.

o waveInAddBuffer: le pasamos el buffer de captura al dispositivo.

- waveInStart: comenzamos la captura.


- 19 -

Cada vez que la aplicación reciba un buffer lleno:

o Procesamiento del buffer.

o waveInAddBuffer del buffer recién procesado para encolarlo.

Cuando deseemos terminar la captura:

- waveInReset, lo cual nos devuelve todos los buffers en el estado en el que se

encuentren, pero esta vez tras procesarlos no los encolaremos.

Una vez por cada buffer que hayamos usado:

o waveInUnprepareHeader: liberamos la estructura del buffer.

- waveInClose: liberamos el dispositivo de captura.

Se ha mencionado en múltiples ocasiones que cuando un buffer de captura se llene

será enviado a la aplicación. Esta notificación de buffer lleno podrá ser realizada de

distintas formas, indicando la forma deseada en el momento de abrir el dispositivo de

captura con waveInOpen:

Mediante una llamada a una función callback, que generalmente se llamará

waveInProc, siendo uno de sus parámetros de entrada el buffer lleno. Esta

función será ejecutada en el hilo principal del programa. Tiene muchas

limitaciones, como el hecho de no poder llamar desde dentro de esta función

ninguna otra función de tipo waveInX ni ninguna función del sistema, por lo que

no ha sido utilizada.

Mediante un mensaje a la ventana de la aplicación. Las aplicaciones de ventanas

en Windows se basan en un bucle infinito de espera de llegada de mensajes de

cualquier índole. Podríamos preparar la aplicación para la llegada de mensajes

por parte del dispositivo de captura, y cada vez que llegase el mensaje

correspondiente, procesar el buffer, ya que el puntero al buffer sería un

parámetro del mensaje. Este procesamiento se realiza en el hilo de ejecución

principal del programa, por lo que esta solución no fue elegida tampoco.


- 20 -

Mediante la llegada de un mensaje a un hilo del programa. Esta solución fue la

elegida por la flexibilidad que ofrece el manejo de todo lo relacionado con el

procesamiento de audio en hilos independientes, sin limitaciones de uso de

llamadas del sistema. Además también proporciona un aumento de rendimiento

en procesadores capaces de ejecutar varios hilos a la vez, como los

HyperThreading o los multi-núcleo. El puntero al buffer lleno llegará como

parámetro de un mensaje al hilo elegido, el cual deberá estar preparado para la

llegada de mensajes y su procesamiento.

Sistema de Recluta de Audio para Bases de Datos de Voz PROYECTO HESPERIA

- 21 -

4. PROYECTO HESPERIA

El proyecto Hesperia [11] surge para atender

necesidades de seguridad aplicables principalmente en

ámbitos públicos. Se trata de sistemas de seguridad

innovadores e inexistentes en la actualidad, aplicables entre otros, a infraestructuras

públicas que requieren un tratamiento especializado, como serían centrales de agua o de

comunicaciones, y también grandes espacios como aeropuertos, zonas peatonales, etc.

El proyecto está adscrito al programa de Consorcios Estratégicos Nacionales en

Investigación Técnica (CENIT), el cual ha recibido del CDTI, organismo adscrito al

Ministerio de Industria Turismo y Comercio, una financiación de doscientos millones

de euros, que junto con una financiación adicional del sector privado sumará 430

millones de euros.

Entre las organizaciones que integran el CENIT están Indra Software Labs, Unión

Fenosa, la Universidad Politécnica de Madrid, la de Cataluña, etc.

Algunos de los objetivos del proyecto Hesperia son los siguientes:

- Detección de riesgos para personas y lugares.

- Interpretación de situaciones complejas para su correspondiente reacción.

- Representación del entorno de una forma intuitiva.

- Conservación de la privacidad de las personas en situaciones comunes.

- Proporcionar información completa sobre incidentes.

- Manejo seguro de operaciones a distancia.

Una de las técnicas del proyecto es la que posibilita el reconocimiento de

parámetros biométricos de la voz. Este sistema estaría a su vez complementado por una


- 22 -

parte encargada del reconocimiento visual gracias a una cámara. La presente aplicación

de captura de voz y ayuda a las sesiones de grabación, se situaría en el primer paso en el

proceso de reconocimiento biométrico de locutor. Mediante esta aplicación se extraería

la voz desde cuatro micrófonos distintos, para luego continuar el procesamiento de lo

grabado, como una labor de troceado en palabras de las frases leídas, y el posterior

análisis. En la figura 4.1 se muestran los distintos módulos del sistema.

Figura 4.1. Esquema del reconocedor biométrico de Hesperia

Como hitos importantes del proyecto Hesperia se pueden destacar ente otros su

participación dentro de la competición Google Android Challenge. Con esta

competición Google pretende motivar el desarrollo de todo tipo de aplicaciones para su

nuevo sistema operativo libre para dispositivos móviles, Android. Indra SL, dentro del

proyecto de investigación Hesperia, ha presentado una aplicación destinada a la

seguridad en distintos ámbitos (Figura 4.2), que son:

Transmisión de vídeo en tiempo real. Esto ofrece la posibilidad de obtener las

imágenes de cámaras situadas en cualquier lugar de una instalación desde un

dispositivo móvil, dando información adicional a un agente desplazado en casos

como el saltar de una alarma.


- 23 -

Visualización de elementos geolocalizados en un mapa. Mediante el uso de

capas específicas obtenidas de un servidor. Esto puede usarse para comprobar el

estado de lugares como las estaciones eléctricas de Unión Fenosa.

Obtención de otro tipo de información de fuentes externas como información

meteorológica, o información de protección civil.

Figura 4.2. Aplicación de seguridad para el sistema Android


- 24 -

Figura 4.3. Reconocedor de emociones del proyecto Hesperia

Por otro lado, dentro del aparatado de audio y vídeo cognitivo, el proyecto Hesperia

en Mayo de 2008 realizó la primera versión de un software para el reconocimiento de

emociones (Figura 4.3). El sistema es capaz de reconocer una serie de parámetros en la

voz del usuario con los que es capaz de saber con bastante precisión el estado en el que

se encuentra el locutor. Esto entre otros usos tendría el de fortalecer los sistemas de

autenticación, ayudando a verificar que el usuario es quien dice ser.

Sistema de Recluta de Audio para Bases de Datos de Voz DESCRIPCIÓN DEL PRODUCTO

- 25 -

5. DESCRIPCIÓN DEL PRODUCTO

En este apartado se mostrará la aplicación realizada, explicando de forma general

cuáles son sus capacidades y las formas en que se llevan a cabo las operaciones. No se

entrará en excesivo detalle sobre los pasos a seguir para su funcionamiento y su

configuración, ya que todos esos aspectos se describen en el manual de usuario.

5.1. Visión general

Primero mostramos en la figura 5.1 el aspecto de la ventana de la aplicación recién

abierta.

Figura 5.1. Ventana principal de Sesión de Grabación


- 26 -

La única información que nos proporciona el programa en un primer momento será

la relacionada con los parámetros de grabación, en la barra de estado en la parte inferior

de la ventana. Esta información se compone de la frecuencia de muestreo, tamaño de la

muestra, y el nombre de cada dispositivo de captura junto con los canales con los que

está configurado para grabar, mono cuando sea un solo canal o estéreo cuando sean dos

canales.

La primera operación que normalmente se va a querer realizar es la de seleccionar

una sesión para un locutor determinado. Con el nombre de sesión nos referimos a un

conjunto de ejercicios de lectura que el locutor va a tener que completar en secuencia,

ya sea leyendo palabras sueltas o frases enteras. Para acceder a esta primera operación

haremos click en el botón o en Archivo→Nueva sesión. Aparecerá una nueva

ventana con las opciones de sesiones y locutores, como puede observarse en la figura

5.2.

Figura 5.2. Selección de locutor y sesión


- 27 -

Dentro de esta ventana tenemos acceso a la información de todos los locutores y

todas las sesiones de grabación que hayamos almacenado previamente. En la parte

derecha veremos la lista de sesiones, y para cada sesión todos los ejercicios de que está

compuesta. En la siguiente pestaña “Datos locutor”, veremos los datos personales del

locutor seleccionado, como su nombre, su dirección y otros datos, destacando su código

único. Por último también se podrán configurar ejercicios personalizados para cada

locutor en la tercera pestaña “Frases personales”.

Una vez hayamos seleccionado al locutor que vaya a realizar los ejercicios y la

sesión que queremos que comience en la primera pestaña, podremos dar comienzo

haciendo click en “Abrir sesión”. Esto provocará varios efectos. Lo primero, veremos

que los datos principales del locutor ahora aparecen en la ventana principal, además de

la lista de ejercicios de la sesión. En este momento se debe tener en cuenta que cada una

de las sesiones que se vayan a realizar, estarán desarrolladas dentro de una presentación

PowerPoint donde se explique al locutor los pasos que debe seguir. En el recuadro

blanco de la parte derecha de la ventana se mostrará dicha presentación para que el

usuario de Sesión de Grabación pueda saber qué está viendo el locutor en su monitor.

Un segundo más tarde la presentación a pantalla completa aparecerá en la pantalla

secundaria situada frente al locutor. En la figura 5.3 vemos el aspecto de la ventana

principal tras haber abierto una sesión.


- 28 -

Figura 5.3. Ventana principal con sesión seleccionada

En este momento o antes de seleccionar una sesión y un locutor, podríamos elegir

cambiar la configuración de captura de audio. Para ello haríamos click en el botón o

mediante Herramientas→Configuración. Esto abrirá una ventana donde tenemos acceso

a los aspectos más relevantes en la captura de sonido, como puede verse en la figura 5.4.


- 29 -

Figura 5.4. Ventana de configuración de captura de audio

Lo primero que destaca en esta ventana es la selección de dispositivos de captura de

sonido, permitiendo la selección de 2 dispositivos distintos. Esta posibilidad surgió de la

necesidad de uso de un dispositivo de captura avanzado MOTU, el cual no se comporta

como una tarjeta de sonido común, ya que sigue unos protocolos especiales. Debido a

esto, el sistema operativo Windows reconoce a cada uno de estos dispositivos como un

conjunto de distintos dispositivos. Concretamente la parte dedicada a la entrada de

audio MOTU la reconoce como dos dispositivos diferentes, cada uno con 2 canales de

grabación. Sabiendo esto, y siendo un requisito indispensable la posibilidad de

grabación en 4 canales diferentes, la aplicación debía ser capaz de visualizar los dos

dispositivos que Windows ve en la tarjeta MOTU y poder usarlos simultáneamente.

Esta posibilidad de seleccionar dos dispositivos, por otro lado nos da versatilidad, ya

que en un momento determinado podríamos querer pasar a utilizar un micrófono

externo conectado al PC, y a la vez un micrófono conectado al dispositivo MOTU,


- 30 -

pudiendo seleccionar sin problemas esta configuración, e incluso eligiendo usar 2

canales para uno de ellos, pero un solo canal para el otro.

Además de la selección de dispositivos podremos elegir entre las frecuencias de

muestreo más comunes, variando desde las 8000 muestras por segundo a las 48000.

También el tamaño de muestra, con las posibilidades de 8 y 16 bits por muestra, y los

canales que deseamos usar en cada dispositivo seleccionado. Por último podremos

seleccionar el tamaño del buffer de captura. El concepto de buffer de captura fue

explicado al detalle en el apartado de “Captura con doble buffer”. Podremos seleccionar

entre tres posibles valores expresados en bytes, 4096, 8192 ó 16384. Estos valores nos

permiten seleccionar la fluidez con la que se va a desarrollar la captura. Un tamaño

pequeño de buffer va a suponer que estos se llenen más rápido y por tanto tengamos que

procesarlos cada menos tiempo. Al procesarlos con menos intervalo de tiempo, el

pintado de la onda de sonido que veremos a continuación será más fluido, pero requerirá

una mayor potencia de computación. Un tamaño grande de buffer implica procesarlos

con un gran intervalo de tiempo, y por tanto sin necesidad de mucha potencia de

cómputo, pero el pintado puede verse menos fluido.

Una vez configurados los parámetros de grabación y abierta una sesión para un

usuario, el uso más común que se hará de la aplicación será una repetición de los

siguientes pasos:

- El usuario seleccionará en la lista de ejercicios de la sesión el ejercicio que va a

realizar el locutor.

- Pasar a la siguiente transparencia de la presentación. Para ello pulsaremos el

botón de avance o accederemos al menú de manejo de la presentación, en

Herramientas→Presentación. En cada presentación vendrá explicado al locutor

lo que deberá hacer, aunque podremos complementarlo con alguna instrucción

hablada por parte del usuario.


- 31 -

- Cuando el ejercicio vaya a dar comienzo, se pulsará el botón de comienzo de

grabación y el/los dispositivo/s de captura comenzarán a grabar.

- Cuando el ejercicio haya terminado, el usuario parará la grabación pulsando en

el mismo botón de grabar, aunque ahora ha adoptado el icono de parar .

Automáticamente se habrá guardado un fichero WAV por cada canal de

grabación.

Durante el progreso de la grabación de un ejercicio tendremos dos formas de

visualizar el sonido entrante. Por un lado en la parte inferior de la ventana principal a la

izquierda, podremos ver una barra por cada canal de grabación marcando la intensidad

de ese canal. Por otro lado, a la derecha de estas barras hay un panel oscuro donde se

dibujará la forma de la onda de sonido en color verde. Si en algún momento se

alcanzase un nivel de saturación en alguno de los canales, esto es, que debido a un

sonido excesivamente alto en ese canal alcanzase el límite superior e inferior

representable (es decir, para 16 bits por muestra, 32767 y -32768, y para 8 bits 127 y

-128), en vez del color verde, la onda se mostraría en color rojo para destacar las zonas

de saturación. En la figura 5.5 se puede ver el aspecto de la ventana principal durante la

grabación.


- 32 -

Figura 5.5. Ventana de Sesión de Grabación durante una grabación

Junto con las funcionalidades básicas ya explicadas existen algunos añadidos que

amplían las posibilidades de uso. Son las siguientes:

Los 4 botones numerados situados bajo el botón grande de grabación, que

sirven para poder reproducir cada uno de los 4 canales grabados

independientemente.

Cronómetro bajo los botones de reproducción que permite conocer con precisión

de décimas de segundo la duración del ejercicio actual.

Barras de limitación del nivel de entrada de cana canal, situadas a la izquierda de

las barras de medición de intensidad. Antes de una grabación se puede elegir que


- 33 -

cada uno de los canales no grabe al 100% de su volumen, sino limitarlo para así

evitar que un micrófono más sensible que el resto grabe con demasiada

intensidad, estando descompensado con el resto.

Botones de manejo de la presentación para un mayor control sobre la misma.

Estos botones se encuentran situados sobre el recuadro de la presentación en

miniatura, permitiendo ir a la primera transparencia, retroceder, ir a la

transparencia deseada u ocultar la presentación al locutor.

5.2. Ventajas que ofrece

La presente aplicación surge como un intento de mejorar la eficiencia y sencillez

con que se llevan a cabo los procesos de grabación de los ejercicios a los locutores. A

continuación se describe el proceso original de grabación de las sesiones, tras lo cual se

analizará el porqué de la nueva aplicación y cómo se han abordado los problemas

originales.

El proceso típico conllevaba disponer de dos personas, cada una con un PC, situadas

más o menos cerca de donde se encuentra el locutor. Una de ellas será la encargada de

tener abierta una aplicación de grabación y edición de audio, que además sea compatible

con el dispositivo de captura usado. Esta persona podrá controlar los niveles de entrada

de cada uno de los micrófonos y configurar todos los parámetros necesarios de la

grabación. La otra persona tendrá abierta en su PC la presentación de PowerPoint. A su

PC estará conectada la pantalla que está viendo el locutor, que es lo mismo que puede

ver este usuario en el PC. Este usuario será el encargado de avanzar en los ejercicios de

lectura en el momento adecuado. Entre los dos usuarios deberá haber una comunicación

durante todo el proceso de los ejercicios. Así, cuando el primero tenga preparada la

grabación, avisará al segundo de que pase a la transparencia correspondiente para que el

locutor comience a hablar. Por supuesto la comunicación entre ambos debe ser


- 34 -

silenciosa ya que en este tipo de ejercicios debe realizarse en ambientes sin ningún tipo

de ruido que interfiera en la grabación.

La configuración explicada se describe esquemáticamente en la figura 5.6.

Figura 5.6. Esquema de realización de ejercicios antes de Sesión de Grabación

Aunque con este método de trabajo se han podido completar numerosas sesiones de

ejercicios sin mayores inconvenientes, existen una serie de problemas intrínsecos a este

tipo de funcionamiento:


- 35 -

Necesidad de un mínimo de dos personas para la realización.

Mayor necesidad de recursos, al requerir dos PCs en lugar de uno solo.

Posibles problemas de comunicación entre operarios al necesitarse silencio.

Posibles problemas de visibilidad de la pantalla donde se muestran los ejercicios

al locutor, por parte del usuario que maneja la aplicación de grabación.

Necesidad del usuario de la aplicación de grabación de introducir los nombres de

los ficheros grabados tras cada ejercicio.

En definitiva estos problemas afectan de forma directa a la eficiencia del proceso de

realización de ejercicios. Con el desarrollo de la aplicación Sesión de Grabación se ha

podido aumentar notablemente la eficiencia del proceso debido a que:

Sólo hace falta un usuario que controlará todos los aspectos del proceso.

Todo se realiza con una sola aplicación en un solo PC → disminución de

recursos necesarios.

Visualización permanente de lo que el locutor tiene ante él.

Automatización de la generación de ficheros de audio.

De esta forma, la misma persona controlará el avance de las transparencias

mostrando los ejercicios, a la vez que configura los parámetros de grabación y controla

el comienzo y fin de los ejercicios, obteniendo finalmente los ficheros WAV

correspondientes sin preocuparse de que estén almacenados con el nombre y en la

ubicación correctos. Se reduce notablemente el tiempo del proceso y disminuye la

probabilidad de problemas técnicos derivados del uso de dos máquinas en lugar de

una. Además se evitan problemas de nombramiento de ficheros, que podrían obligar

a la repetición del ejercicio.

Sistema de Recluta de Audio para Bases de Datos de Voz ASPECTOS TÉCNICOS

- 36 -

6. ASPECTOS TÉCNICOS

En este apartado se hablará de los distintos aspectos de carácter técnico que han

envuelto el proceso de creación de esta aplicación. Se hablará del lenguaje de

programación escogido comentando sus ventajas y cómo han influido sus características

al desarrollo. Se entrará en aspectos más concretos que merecen mención especial como

el manejo de PowerPoint desde la aplicación. Por último se comentarán todos los

aspectos de mejora y optimización que se pensaron y tuvieron en cuenta hasta que el

producto alcanzó su estado definitivo.

6.1. Elección del lenguaje

Para el desarrollo de la aplicación se eligió usar el lenguaje C++. Este lenguaje

ofrece características muy positivas para la realización de un proyecto. Ofrece la

posibilidad de realizar operaciones a bajo nivel obteniendo gran potencia. Esto también

se debe a la precisión del manejo de la memoria que ofrece, que aunque exigiendo un

uso más elaborado que otros lenguajes de más alto nivel, aporta resultados de

rendimiento superiores.

Esta misma consideración fue tomada en el desarrollo de una aplicación anterior

únicamente encargada de la captura por micrófono sencilla. Al tener este código ya

hecho en C++ facilitaría el desarrollo de la parte de Sesión de Grabación encargada de

la captura (aunque requiriese numerosas ampliaciones y mejoras), por lo que la

reutilización de código resultó ser otro punto más a favor de la elección de C++.

Uno de los puntos negativos que se pueden atribuir a C++ resulta lo complejo que

resulta el desarrollo de una interfaz gráfica para una aplicación de ventanas para el

sistema Windows. Este tipo de aplicaciones nativas de Win32 se basan en el uso de

mensajes. Cualquier suceso dentro del programa se gestiona como un mensaje, ya sea


- 37 -

desde la pulsación de un botón, como el cambio de tamaño de una ventana o la

selección de un texto. Un programa Win32 requiere realizar un procesado adecuado de

estos mensajes, y para manejar cualquier aspecto gráfico se deben enviar mensajes a los

controles que deseemos utilizar. Por ejemplo, si quisiésemos cambiar el color de una

barra de progreso, deberíamos localizar el manejador de dicha barra a través de su

identificador y del manejador de la ventana que lo contiene, y mandar un mensaje con

estos datos y unos determinados parámetros, entre los cuales se encontraría el color al

que queremos que cambie.

En una aplicación pequeña como era la ya mencionada anterior aplicación

encargada únicamente de la captura de audio desde un único dispositivo, este manejo de

mensajes podía resultar algo tedioso en un principio, pero se hacía abarcable y

comprensible debido a su corta extensión. Sin embargo en un programa mucho más

extenso con muchas funcionalidades distintas y un apartado gráfico mucho más amplio,

la programación mediante mensajes, aunque aportando un gran rendimiento, podría

complicar innecesariamente el desarrollo y la depuración, al ser un código poco legible

y difícil de corregir.

Para abordar este problema, existen diferentes librerías que ayudan a la abstracción

del uso de mensajes, aportando funciones más fáciles de usar que en el fondo realizan

llamadas al API de Win32. Uno de los compendios de funciones más conocidos es el

MFC (Microsoft Foundation Class Library) que aporta numerosas clases para el

desarrollo de aplicaciones de ventanas sin necesidad de introducirse en el uso de

mensajes ni llamadas al API de Win32. Aunque esto resultaba un avance y facilitaba el

desarrollo de sistemas complejos, seguía requiriendo el uso de una estructura compleja

en las aplicaciones que aún podía resultar tediosa para un programador que

desconociese este entorno.

Más adelante Microsoft creó .NET, un entorno de desarrollo más moderno y en

constante evolución, que en la misma línea que el MFC aporta numerosas clases que

nos permiten olvidarnos del uso de mensajes y de la antigua y compleja estructura de


- 38 -

los programas que usan ventanas, para programar de una manera más intuitiva. En el

próximo apartado se hablará más detenidamente de las ventajas y características de

.NET. Basta decir que vista la importancia del apartado gráfico de la aplicación Sesión

de Grabación y la facilidad que .NET ofrece para este fin, se eligió el uso de .NET bajo

la programación con C++.

6.2. Características de .NET

6.2.1. ¿Qué es .NET?

Como ya se ha comentado en el apartado anterior, .NET [12] es un conjunto de

bibliotecas creadas por Microsoft, que contienen clases para la programación orientada

a objetos, que permiten realizar las tareas más típicas que un programador va a necesitar

en su día a día, y todo completamente comentado y explicado en el compendio de

manuales de referencia para programadores de Microsoft, el MSDN. Algunos ejemplos

de las clases que podemos encontrar en .NET serían aquellas para el manejo de

estructuras de datos, como vectores o listas enlazadas, clases para la medición de

tiempos o clases para la incorporación de todo tipo de controles como botones o

etiquetas a una interfaz gráfica.

.NET no es sólo un conjunto de bibliotecas, sino también un propósito de unificar

los lenguajes de programación y ayudar a la portabilidad entre distintas plataformas. Lo

primero lo consiguen permitiendo usar todas las clases de .NET desde distintos

lenguajes de programación, como son C++, Visual Basic, C# o J#. Las llamadas a los

métodos o el uso de los tipos de datos serán idénticamente los mismos se use el lenguaje

que se use, lo que también ayuda al uso de distintos lenguajes dentro de una misma

aplicación, combinándolos sin problemas. Además es beneficioso para el

mantenimiento de sistemas, ya que un programador de .NET podrá mantener una


- 39 -

aplicación sin problemas, ya esté escrita en C++ o en Visual Basic. Por otro lado, la

portabilidad entre hardware diferentes se consigue mediante lo que Microsoft llama el

.NET Framework. Cualquier máquina que use Windows, ya sea XP, Vista o Mobile,

mientras tenga instalado el Framework de .NET podrá ejecutar una aplicación

desarrollado con .NET de forma idéntica al resto de sistemas Windows.

El núcleo del Framework de .NET es el llamado CLR (Common Language

Runtime) [13], y es el encargado de ejecutar el código del programa desarrollado en

.NET en la máquina en la que se encuentre. En la figura 6.1 se puede ver un diagrama

con la estructura del CLR. En las últimas versiones de .NET (a partir de la 2.0) se han

hecho avances y actualizaciones en el CLR que requieren en algunos casos cambiar la

forma en la que antes se programaba, afectando esto especialmente a Visual C++. Con

CLR se debe programar con el llamado código administrado (managed code en inglés).

CLR cuenta con un recolector de basura similar al del lenguaje Java, y esto hace que ya

no sea tan estrictamente necesaria la liberación manual de memoria al terminar de usar

cualquier elemento que la hubiese reservado previamente. De todas formas algunas

estructuras más complejas, como algunas relacionadas con el pintado de figuras, siguen

requiriendo la liberación manual de memoria tras su uso para mejorar el rendimiento de

la aplicación.

Figura 6.1. Diagrama interno de CLR

Por otro lado, al programar en C++ para CLR debemos olvidarnos de los punteros

como antes los conocíamos. Ahora al programar con .NET en cualquiera de sus


- 40 -

lenguajes, se hace el uso de los llamados manejadores (handlers en inglés). Ya no se

hace uso del heap para reservar objetos en memoria, sino que la memoria se administra

de una forma más “inteligente” debido al uso del mencionado recolector de basura. No

podemos tener en principio un puntero a una dirección de memoria donde se encuentre

un objeto, sino que ahora tendremos un manejador, que actuará como un rastreador del

objeto en cuestión a través de la memoria, ya que su posición puede cambiar en el

tiempo. Al programar en C# o Visual Basic esto no tiene mayor importancia en la forma

de programar, ya que todas nuestras variables en principio serán punteros (ahora

manejadores). Sin embargo en Visual C++ ya no se usarán los asteriscos que antes

servían para designar un puntero a un objeto, sino que usaremos el símbolo „^‟ que

indicará que lo anterior se trata de un manejador a un objeto en memoria.

6.2.2. Interoperabilidad entre .NET y el API de Windows

Con esta nueva y más cómoda forma de manejar la memoria al programar, tenemos

algunas limitaciones. La más importante es que no se puede mezclar código

administrado con código no administrado, ya que cada uno hace un uso distinto de la

memoria. Esto en principio no debería ser una limitación si nos ceñimos al uso de las

clases y los métodos que nos proporciona .NET, pero muchas veces no será suficiente

con esto, en especial si deseamos realizar un manejo más profundo y específico de

algún hardware de la máquina u otro tipo de operación poco común como podría ser

hacer clicks de ratón mediante código. Este tipo de operaciones pueden ser realizadas

mediante llamadas al API de Windows, pero muchas de estas funciones no tienen su

correspondiente versión en .NET, y usan tipos de datos no administrados.

Concretamente en Sesión de Grabación todo el manejo de las tarjetas de sonido para

la captura y reproducción de sonido, o para el uso del mezclador de Windows, requiere

el uso de llamadas al API. En lenguajes de programación en .NET como Visual Basic o

C#, no podríamos llamar directamente a estas funciones. Para poder usarlas deberíamos


- 41 -

crear en nuestro programa una instancia de esas funciones y todas las estructuras de

datos que necesitasen, sustituyendo los tipos de sus parámetros y de los valores

devueltos, por tipos u objetos que existan en .NET y se comporten de la misma manera.

Para hacer esta instancia de la función del API .NET dispone de la llamada PInvoke,

que dado el DLL donde se encuentre implementada la función del API y el nombre de la

función nos permite redefinirla para adaptarla a CLR. Por poner un ejemplo, podemos

ver cómo es una llamada original a la función waveInOpen del API, que sirve para abrir

un dispositivo de captura de audio:

MMRESULT waveInOpen(

LPHWAVEIN phwi,

UINT_PTR uDeviceID,

LPWAVEFORMATEX pwfx,

DWORD_PTR dwCallback,

DWORD_PTR dwCallbackInstance,

DWORD fdwOpen

);

Para poder usar waveInOpen en un programa CLR como C#, la instanciación de la

función, que se encuentra en la biblioteca dinámica “winmm.dll”, quedaría de la

siguiente manera:

[DllImport("winmm.dll")]

private static extern uint waveInOpen(

ref IntPtr hWaveIn,

uint deviceId,

ref WAVEFORMATEX wfx,

IntPtr dwCallBack,

uint dwInstance,

uint dwFlags

);

Donde la estructura WAVEFORMATEX usada por esta función para definir las

características de la grabación, habría que definirla manualmente como:


- 42 -

public struct WAVEFORMATEX

{

public short wFormatTag;

public short nChannels;

public uint nSamplesPerSec;

public uint nAvgBytesPerSec;

public short nBlockAlign;

public short wBitsPerSample;

public short cbSize;

}

Este tipo de instanciaciones que resultan obligatorias en todos los lenguajes de

.NET, no lo son en C++. En C++ se puede llamar directamente a las funciones del API

en una región de código que además tenga llamadas administradas CLR. Esta es la

llamada interoperabilidad de Visual C++ entre código administrado y código no

administrado [14]. Esta técnica ofrece unas ventajas inmediatas que son la facilidad de

uso de las funciones del API, al no necesitar instanciaciones laboriosas en muchos casos

como las vistas en el anterior ejemplo, aunque siguen estando disponibles en Visual

C++. En una aplicación como Sesión de Grabación, que gran parte de su

funcionamiento se basa en el uso las funciones del API para el manejo de sonido, el

tiempo que ahorra la interoperabilidad de C++ en el desarrollo es notable.

Sin embargo, esta interoperabilidad implícita que tiene Visual C++ no es gratuita y

conlleva unos sacrificios que deben ser tenidos en cuenta antes del desarrollo de

cualquier aplicación de este estilo. La convivencia entre código administrado y no

administrado requiere que la aplicación sea capaz de manejar direcciones de memoria

en el heap, y además manejadores de memoria con recolector de basura. Si se está

ejecutando código CLR y a continuación se llama a una función del API, se cambiará

automáticamente el modo de ejecución a no administrado, y este cambio, como el futuro

cambio a modo administrado, requieren un tiempo y un consumo adicional de recursos.

En una aplicación con unos requisitos de tiempo muy estrictos o con un consumo de

memoria muy limitado, esto podría llegar a ser un inconveniente, pero para la actual

aplicación Sesión de Grabación no representan una amenaza para su correcto


- 43 -

funcionamiento, lo que se ha demostrado en numerosas pruebas posteriores, por lo que

la interoperabilidad de Visual C++ constituye una gran ventaja.

6.3. Manejo de PowerPoint mediante código

La realización de las sesiones de grabación de voz en el laboratorio se basa en el uso

de una presentación PowerPoint que guía al locutor durante los ejercicios. Esta

metodología se ha mantenido intacta al usar Sesión de Grabación, por lo que se debía

encontrar el método de poder manejar la presentación sin que el usuario necesitase

cambiar entre el programa de grabación y la presentación constantemente.

Para el uso de cualquier aplicación del paquete Microsoft Office, originalmente

existían unas bibliotecas destinadas a su uso mediante el lenguaje Visual Basic, que

permitían acceder a la mayoría de las funcionalidades de la aplicación, ya fuese Word,

Excel, Access, etc. Estas funciones de Visual Basic podían ser usadas desde casi

cualquier lenguaje de programación adaptando sus llamadas a la forma propia de cada

lenguaje. Con .NET esto mismo es posible e incluso se ha facilitado aún más, existiendo

unas bibliotecas dinámicas que pueden ser referenciadas desde cualquier aplicación

.NET, permitiendo el manejo de Office en código administrado. Esto es lo que se

conoce como la interoperabilidad con Office.

Al referenciar en el proyecto una biblioteca de manejo de Office, se debe elegir por

un lado para cuál de las aplicaciones de Office queremos la biblioteca. En el caso de

Sesión de Grabación sólo ha hecho falta una referencia a la biblioteca de PowerPoint.

Por otro lado se puede elegir para qué versión de Office queremos la biblioteca. Cada

versión de Office incorpora nuevas funcionalidades que sólo podrán ser accedidas desde

la biblioteca correspondiente de esa versión. El problema podría llegar si, habiendo

usado la biblioteca correspondiente a la última versión de Office, al ejecutar la

aplicación tuviésemos instalado en nuestro PC una versión anterior de Office. En este


- 44 -

caso lo más probable sería que apareciesen problemas de incompatibilidad entre las

versiones, ya que la biblioteca nueva presupone que encontrará en el Office instalado

una serie de parámetros que realmente no tiene por ser una versión anterior.

Para evitar problemas entre versiones y así maximizar la compatibilidad, se ha

decidido usar no la última versión de la biblioteca de PowerPoint (actualmente la

versión 12, correspondiente a Office 2007), sino la anterior, la 11, correspondiente a

Office 2003. Cada versión de las bibliotecas de Office incorpora todo lo de las

anteriores, junto con nuevas características. Sabiendo esto, y tendiendo en cuenta que en

cualquiera de los PCs en los que se vaya a utilizar Sesión de Grabación tiene instalado

Office 2003 u Office 2007, todas las funciones usadas con la versión 11 de las

bibliotecas serán correctamente interpretadas en cualquier máquina.

Todas las funciones, tipos de datos y constantes que se pueden usar para el manejo

de PowerPoint desde código se encuentran explicadas con ejemplos para Visual Basic

en MSDN [15]. A continuación se explicará de forma breve los pasos a seguir para

poder controlar PowerPoint desde código.

Una vez tenemos las referencias a las bibliotecas dinámicas de la versión 11 de

Office y PowerPoint, debemos crear en nuestro código una instancia de la aplicación

PowerPoint. Será como tener una referencia al ejecutable de la aplicación PowerPoint, y

por tanto éste nos proporcionará las opciones básicas como abrir un documento, guardar

o salir. Con esta instancia de la aplicación podremos maximizar o minimizar la ventana

de PowerPoint o incluso tenerla oculta mientras no la usemos. En Sesión de Grabación

permanecerá minimizada para así no interferir en el trabajo del usuario. Una vez

tenemos la referencia a la aplicación PowerPoint podremos abrir la presentación donde

se encuentren los ejercicios de la sesión. La instancia de PowerPoint contendrá un

vector representando el conjunto de presentaciones que tenemos abiertas, y cada

presentación tendrá un vector que es el conjunto de transparencias que posee. En

nuestro caso sólo tendremos abierta una presentación cada vez, ya que un locutor sólo

realizará un conjunto de ejercicios en una sesión.


- 45 -

Una vez tenemos abierta una presentación, podremos realizar cualquier

modificación que queramos sobre sus transparencias. El conjunto de elementos que se

encuentran dentro de una transparencia se ven como un vector de objetos, ya sean

cuadros de texto, imágenes o animaciones. Podremos añadir nuevas transparencias con

el título y puntos deseados. Una vez la presentación sea de nuestro agrado, podremos

acceder también a las propiedades de la exposición de transparencias (slideshow en

inglés), pudiendo así pasar más rápido o más lento de transparencia, o eligiendo el tipo

de transición entre una y otra. Por último se podrá iniciar la exposición de

transparencias a pantalla completa para que pueda ser visualizada por el locutor.

6.4. Evolución y optimización de la aplicación

En este apartado se explicarán algunas de las etapas del desarrollo de Sesión de

Grabación que han resultado especialmente importantes por su implicación en el

rendimiento o uso general de la aplicación, o que han sufrido cambios notables hasta

llegar a la versión definitiva.

6.4.1. Interfaz gráfica

La ventana principal de la aplicación va a ser el punto de contacto principal del

usuario con Sesión de Grabación, ocupando su uso casi el 100% del tiempo, ya que el

resto de ventanas como la correspondiente a la configuración de los parámetros de

grabación o la dedicada a la edición de locutores requerirán un uso sólo ocasional. Por

esto es la ventana principal la que ha tenido variaciones desde el comienzo del

desarrollo donde era prácticamente un esbozo hasta la versión final. En lo que respecta a

los elementos o controles presentes en la interfaz, estos han continuado siendo los

mismos con sólo unas pocas excepciones de principio a fin. Sin embargo no ha ocurrido


- 46 -

lo mismo con la colocación de los mismos. En la figura 6.2 podemos ver la

comparación entre el antiguo aspecto de la interfaz y el nuevo.

Figura 6.2. Comparación entre la primera interfaz y la definitiva

Los cambios realizados han evolucionado teniendo en cuenta un enfoque de

usabilidad, ya que uno de los objetivos principales en los que se ha basado todo el

desarrollo es conseguir que el tiempo de aprendizaje de uso de la herramienta sea muy

reducido, y que el usuario no se pierda entre las opciones para así aprovechar al máximo

el tiempo de trabajo.

Sistema de Recluta de Audio para Bases de Datos de Voz ASPECTOS TÉC

sistema de recluta de audio para bases de...

Documents