aplicaciaciÓn para la recreaciÓn de escenas sonoras

E.T.S. de Ingeniería Industrial, Informática y de Telecomunicación

Aplicación para la recreación de escenas sonoras tridimensionales

Trabajo Fin de Grado

Autor: Rubén Eguinoa Cabrito Tutor: Ricardo San Martín Murugarren Pamplona, 10/06/2020

Grado en Ingeniería en Tecnologías de Telecomunicación

APLICACIACIÓN PARA LA RECREACIÓN DE ESCENAS SONORAS TRIDIMENSIONALES

2

AGRADECIMIENTOS Agradecer la ayuda recibida por parte del Departamento de Acústica de la

Universidad Pública de Navarra, en especial a Ricardo San Martín por la dedicación y entusiasmo mostrado en todo momento.


3

RESUMEN El Trabajo Fin de Grado consiste en la creación de una aplicación de escritorio para

recrear escenas y paisajes sonoros tridimensionales mediante la implementación de la tecnología Ambisonics.

LISTA DE PALABRAS CLAVE − Ambisonics: tecnología de grabación, mezcla y reproducción de audio espacial.

− Binaural: técnica para la reproducción de sonido tridimensional por dos canales de audio basada en las denominadas Head Related Transfer Functions (HRTFs).

− Audio 3D: audio espacial o sonido inmersivo.

− JUCE: framework para la creación de aplicaciones y plugins.

− Sonorizart3: proyecto de desarrollo de una instalación sonora para experimentar con escenas sonoras en audio 3D.


4

ÍNDICE

AGRADECIMIENTOS....................................................................................................................... 2

RESUMEN ...................................................................................................................................... 3

LISTA DE PALABRAS CLAVE ............................................................................................................ 3

1. INTRODUCCIÓN Y OBJETO ..................................................................................................... 6

2. PROYECTO SONORIZART3 ..................................................................................................... 7

3. AMBISONICS .......................................................................................................................... 8

3.1. SISTEMA DE REFENCIA DE UN ESPACIO TRIDIMENSIONAL ........................................... 9

3.2. GRABACIÓN ................................................................................................................... 9

3.3. ARMÓNICOS ESFÉRICOS .............................................................................................. 11

3.4. CODIFICACIÓN DEL CAMPO SONORO ........................................................................ 12

3.5. DISPOSITIVO DE REPRODUCCIÓN ............................................................................... 13

3.6. DECODIFICACIÓN......................................................................................................... 14

3.7. BINAURALIZACIÓN ...................................................................................................... 16

4. JUCE FRAMEWORK .............................................................................................................. 17

4.1. ESTADO DEL ARTE ....................................................................................................... 17

4.2. LA APLICACIÓN ............................................................................................................ 19

4.3. ORGANIZACIÓN DEL CÓDIGO ...................................................................................... 20

4.4. ESTADOS DE LA APLICACIÓN ....................................................................................... 21

4.4.1. ESTADO 1 ............................................................................................................. 21

4.4.2. ESTADO 2 ............................................................................................................. 21

4.4.3. ESTADO 3 ............................................................................................................. 22

4.5. VENTANAS ................................................................................................................... 22

4.5.1. VENTANA 1.1: Bienvenida ................................................................................... 22

4.5.2. VENTANA 2.2: Cargar una escena existente ....................................................... 23

4.5.3. VENTANA 2.3: Crear una escena ......................................................................... 23

4.5.4. VENTANA 3.4: Reproducción y manejo de la escena .......................................... 25

4.5.5. Ventana de alertas .............................................................................................. 26

4.6. DESCRIPCIÓN DE SCRIPTS Y FUNCIONES ..................................................................... 26

4.6.1. Main.cpp .............................................................................................................. 26

4.6.2. Welcome.cpp / Welcome.h ................................................................................. 26

4.6.3. Load.cpp / Load.h ................................................................................................ 27

4.6.4. Create.cpp / Create.h .......................................................................................... 29

4.6.5. MainComponent.cpp / MainComponent.h ......................................................... 31


5

4.6.6. Sphere.h .............................................................................................................. 40

4.6.7. Artist.cpp / Artist.h .............................................................................................. 44

4.7. DISPOSITIVOS EXTERNOS ............................................................................................ 45

4.7.1. Interfaces de audio externas ............................................................................... 45

4.7.2. Controlador MIDI ................................................................................................ 45

4.8. CREACIÓN DE LA SEÑAL AMBISONICS Y REPRODUCCIÓN .......................................... 48

4.8.1. Lectura de archivos ............................................................................................. 48

4.8.2. Reproducción ...................................................................................................... 49

4.8.3. Creación de la señal Ambisonics ......................................................................... 50

4.8.4. Decodificación para la configuración de la esfera y los 8 altavoces ................... 51

4.8.5. Decodificación para auriculares (Binauralización) .............................................. 52

4.9. PRUEBAS ...................................................................................................................... 53

4.10. VISTA A FUTURO ...................................................................................................... 55

5. CONCLUSIONES ................................................................................................................... 55

6. BIBLIOGRAFÍA ...................................................................................................................... 56

7. ANEXOS ............................................................................................................................... 57


6

1. INTRODUCCIÓN Y OBJETO El objeto de este Trabajo Fin de Grado es poner en práctica e investigar sobre los conocimientos adquiridos en el transcurso del grado en Ingeniería en Tecnologías de Telecomunicación de la Universidad Pública de Navarra, sobre todo en el área de acústica y procesado de señales de audio, así como adquirir nuevos conocimientos propios de la labor investigadora.

El audio 3D, también conocido como audio espacial o sonido inmersivo, es un formato en auge gracias al desarrollo de la realidad virtual y los videos en 360°. Con él se pretende conseguir una experiencia sonora completamente inmersiva. Son varias las técnicas existentes para la generación de este tipo de audio. Una de las más implementadas, sobre todo desde que grandes compañías como Facebook o YouTube la integraran en sus vídeos 360°, es la denominada Ambisonics, que se caracteriza por permitir una sencilla manipulación de la escena sonora alrededor de un oyente situado en el centro de ella.

La base de este trabajo es crear una aplicación para la generación, manipulación y representación de escenas y paisajes sonoros dentro del proyecto cultural Sonorizarte (ver segundo apartado). La aplicación deberá ser capaz de recrear la percepción espacial del campo sonoro mediante tecnología Ambisonics de tercer orden. Para ello, será capaz de integrar pistas sonoras y modificarlas para ubicarlas en el espacio auditivo de forma realista. Las escenas así generadas podrán ser reproducidas en el sistema de 24 salidas previsto en la instalación Sonorizarte o en formato binaural (pensado para escuchas previas mediante auriculares).


7

2. PROYECTO SONORIZART3 Sonorizarte nace gracias al Grupo de Investigación Acústica de la Universidad Pública de Navarra, con el afán de acercar a artistas y público general las posibilidades que ofrece el sonido tridimensional. El objetivo principal es crear una instalación sonora para experimentar con escenas y paisajes sonoros en audio 3D. La instalación permitirá exponer creaciones de distintos compositores además de ofrecer interactividad al público para que creen sus propios trabajos en tiempo real.

El proyecto se enmarca dentro de los proyectos culturales 2020 de la Universidad Pública de Navarra, y pretende acercar el trabajo realizado en el Laboratorio de Acústica a espacios menos habituados al lenguaje científico y tecnológico a través del arte. Además, la Comisión Internacional de Acústica (International Comission for Acoustics), ha seleccionado dicho año −2020− como el Año Internacional del Sonido (International Year of Sound), siendo esta una iniciativa global que aspira a resaltar la importancia tanto del sonido como de las ciencias y tecnologías relacionadas con él.

Dicha iniciativa consiste en un conjunto de actividades coordinadas a nivel local, regional, nacional e internacional que tienen como objetivo reflexionar sobre el papel que juega el sonido en diferentes ámbitos de la sociedad moderna, desde el puramente comunicativo al musical o artístico. Fomentando, al mismo tiempo, la necesidad de controlar los ambientes sonoros en la naturaleza y en los espacios de trabajo y ocio, con el objetivo de garantizar entornos de relación humana saludables y seguros. Sonorizarte trata de poner su granito de arena, ayudando en la creación y grabación de escenas tanto naturales (fiestas populares, carnavales, conciertos, bosques, reservas naturales, etc.) como artificiales, y creando un dispositivo capaz de transportar al público a esos lugares.

En el proyecto colaboran UpnaLab Makers, la Unidad de Audiovisuales del Centro Superior de Innovación Educativa de la UPNA, el Departamento de Escultura de la Escuela de Arte y Superior de Diseño de Pamplona, la Fundación Elkarte, compositores, y el Grupo de Investigación Acústica de la UPNA, el cual ha involucrado a estudiantes de últimos años de carrera y de donde nace la idea de este Trabajo Fin de Grado.

Figura 1 - Diseño de la esfera de sonido tridimensional FUENTE : matarnoldaudio.com/vr-audio/ambisonic-0audio-and-virtual-reality/

http://matarnoldaudio.com/vr-audio/ambisonic-audio-and-virtual-reality/


8

3. AMBISONICS [1, 2] Ambisonics es una tecnología de grabación, mezcla y reproducción de audio espacial. La tecnología Ambisonics de Primer Orden (FOA) fue desarrollada en 1970 por P. Felgett, M.A. Gerzon y P. Craven, basándose en los principios básicos de grabación coincidente y reproducción de audio investigados a partir de 1930. La técnica no ha tenido apenas uso fuera del ámbito académico e investigador, hasta que ha sido adoptada por las principales empresas tecnológicas de internet para proyectos de audio y video en 360° y ha sido la base de los dispositivos de realidad virtual (VR).

La grabación coincidente se basa en el manejo de micrófonos direccionales, situados de tal forma que el espacio entre ellos sea el menor posible, intentando conseguir que el audio llegue con el mismo retraso a los distintos micrófonos. Las técnicas más representativas son la grabación XY (la pareja de Blumlein) y la grabación MS.

La base para conseguir espacialidad sonora es conseguir captar y reproducir con exactitud la dirección de procedencia de una fuente sonora. Para ello, Ambisonics discretiza el espacio en armónicos esféricos. Una determinada región de la esfera estará asociada a un conjunto de armónicos esféricos con su peso correspondiente. De esa manera, Ambisonics trata una escena sonora como una esfera completa de 360° con sonido llegando desde cualquier dirección hasta un punto central. Dicho punto central se sitúa en la posición del micrófono de grabación o sweet spot. Para órdenes bajos, que utilizan menos armónicos esféricos, una vez se sale de esa zona la percepción de procedencia deja de ser fiable. Este es uno de los mayores problemas que acarrea Ambisonics de primer orden y, junto a la necesidad de una mayor resolución espacial, ha provocado que se desarrollen órdenes superiores.

Figura 2 - Área perceptual del sweet spot para Ambisonic de primer (gris suave), tercer (gris

oscuro) y quinto (negro) orden. Marca el área donde las direcciones recibidas son plausibles. Fuente: [1]


9

3.1. SISTEMA DE REFENCIA DE UN ESPACIO TRIDIMENSIONAL

Para hacer uso de un espacio tridimensional, en este caso con forma de esfera, es necesario tener un sistema de referencia. Para poder marcar un punto (la dirección del sonido) en el espacio, serán necesarias tres variables: acimut (ϕ), elevación (δ) y distancia (r). Los sonidos procederán del punto P(ϕ, δ) o P(θ), donde θ es el vector unitario de dirección. Dicho vector se puede definir en coordenadas cartesianas con las direcciones x, y, z; designados como i, j y k.

3.2. GRABACIÓN

Para hacer una grabación Ambisonics de primer orden, son necesarios cuatro micrófonos: uno de patrón omnidireccional y tres con patrón de figura de ocho (alineados en los ejes de las coordenadas cartesianas x, y, z), los cuales generarán cuatro señales: W, X, Y, Z, respectivamente.

Estas cuatro señales obtenidas (W, X, Y, Z) marcan el estándar para la grabación Ambisonics de primer orden. Este formato estandarizado se denomina B-format y permite una manipulación sencilla de una escena sonora.

Es posible obtener los mismos resultados mediante cuatro micrófonos con patrón cardioide colocados de forma que cubran un área de forma esférica, en

Figura 3 - Sistema de referencia en 3D Fuente: [15] - Modificada

Figura 4 - Grabación Ambisonics tridimensional (izq.) y dispositivo de grabación (dcha.)

Fuente: [1]

δ θ


10

configuración tetraédrica. Este tipo de configuración da pie a la creación de dispositivos que llevan integrados los cuatro micrófonos creando un formato propio de grabación, habitualmente denominado A-format.

Las cuatro señales así obtenidas se denominan FLU (Front Left Up, en referencia al micrófono colocado enfrente, a izquierda y arriba), FRD (Front Right Down, en referencia al micrófono colocado enfrente, a derecha y abajo), BLD (Back Left Down, en referencia al micrófono colocado detrás, izquierda y abajo) y BRU (Back Right Up, en referencia al micrófono colocado detrás, a derecha y arriba).

Como se observa en la figura 5, es necesario modificar las señales obtenidas con la configuración tetraédrica para conseguir los cuatro canales necesarios en formato Ambisonics. Es decir, hay que convertir el A-format en B-format. La ecuación 1 muestra la codificación de una señal con procedencia θ que genera un micrófono de grabación en formato A.

g(θ)= 1

2+

1

2

[ θFLU

T

θFRDT

θBLDT

θBRUT ]

θ= 1

2+

1

2

1

√3 [

1 1 11 -1 -1-1-1

1-1

-11

] θ

Ecuación 1

La conversión de dicha señal al formato B se consigue mediante una matriz que añade las señales de todos los micrófonos en la primera línea (del canal W, omnidireccional), separa la señal frontal-trasera en la segunda línea (del canal X, figura de ocho), separa la señal derecha-izquierda en la tercera línea (del canal Y, figura de ocho) y separa la señal arriba-abajo en la cuarta línea (del canal Z, figura de ocho).

Figura 5 – Configuración tetraédrica con cuatro micrófonos cardioides (izq.) y mezcla de las señales para la codificación de las señales W, X, Y, Z (dcha.)

Fuente: [1]


11

gWXYZ(θ)=

1

2 [√3

1 1 1 1

(1 1 -1 -11 -1 1 -11 -1 -1 1

)] g(θ)

Ecuación 2

3.3. ARMÓNICOS ESFÉRICOS

Los armónicos esféricos son la base de la tecnología Ambisonics, ya que la señal se reconstruye mediante la combinación de los mismos. A mayor cantidad de armónicos mayor resolución espacial. La cantidad de armónicos viene dada por el orden en el que se esté trabajando. A mayor orden, mayor cantidad de armónicos. Para un orden N serán necesarios (N+1)² armónicos, 2N + 1 si la reproducción es en dos dimensiones.

Una señal Ambisonics de primer orden (FOA), codificada como se describe en el apartado anterior, utiliza los cuatro primeros armónicos. Para crear una señal de tercer orden, se necesitarán 16 armónicos, todos los que aparecen en la figura 6.

A la hora de numerar los armónicos, existen dos convenciones, las cuales pueden dar a equívoco si se mezclan entre ellas: FuMa (en desuso) y ACN. La primera nombra todos los armónicos mediante letras (como se ha hecho con B-format de primer orden y sus caracteres asociados a cada canal W, X, Y, Z). La segunda los nombra numéricamente (ACN = n² + n + m, con n = orden y m = grados), siendo una clasificación más natural conforme se sube de orden.

Figura 6 - Armónicos esféricos para cada orden Fuente: [14]


12

Tabla 1 - Convenciones FuMa y ACN

FuMa ACN

Figura 7 - Notación FuMa

Figura 8 - Notación ACN

3.4. CODIFICACIÓN DEL CAMPO SONORO

Para codificar una escena, tomada ésta como una señal variable definida en la superficie de una esfera que rodea un punto f(φ, δ, t), serán necesarios dos términos: los armónicos esféricos Yn

m(φ, δ) y los coeficientes de expansión (o señales) ∅nm(t), siendo el orden n y el grado m. La escena será la combinación de todos los armónicos, cada uno multiplicado por su señal asociada. Es decir, se multiplica la señal que llega al armónico en un instante concreto t y se suma para todos los grados y órdenes.

f(φ, δ, t)= ∑ ∑ Ynm(φ,δ) ∅nm(t)

n

m=-n

N

n=0

Ecuación 3

Los armónicos esféricos, a su vez, se componen de dos términos: un término de

normalización Nn|m| y su polinomio de Legendre asociado Pn

|m|. Los polinomios asociados de Legendre son los resultados canónicos a la ecuación general de Legendre, la cual soluciona la ecuación de Laplace.

Ynm(φ, δ) = Nn

|m|Pn|m|(sin(δ)) {

sin|m|φ

cos|m|φ

m<0m≥0

Ecuación 4

Para una reconstrucción óptima del campo sonoro, es de vital importancia la

normalización de los armónicos esféricos lograda mediante Nn|m|. Respecto a este

tema hay varios enfoques, los más conocidos son la normalización completa (N3D) y la semi-normalización de Schmidt (SN3D, más extendido en Ambisonics).

Con la normalización SN3D, ningún término excederá el valor pico del orden cero. Sin embargo, la normalización N3D asegura una potencia igual en todos los componentes codificados, siempre y cuando se de un campo 3D perfectamente


13

difuso, lo que puede acarrear problemas a la hora de decodificar y causar distorsión en órdenes superiores.

Tabla 2 - Funciones de normalización N3D y SN3D y su relación (abajo)

N3D SN3D

Nn|m|(N3D)=√

(2n+1)(n-|m|)!

2(n+|m|)!

Ecuación 5

Nn|m|(SN3D)=√

1(n-|m|)!

2(n+|m|)!

Ecuación 6

Nn|m|(N3D)=√(2n+1)N

n

|m|(SN3D)

Ecuación 7

3.5. DISPOSITIVO DE REPRODUCCIÓN

Un factor determinante para la reproducción de escenas codificadas en Ambisonics, es la configuración de los altavoces de salida. La forma más adecuada para crear un sistema de presentación es situar los altavoces equiespaciados respecto a un punto central generando poliedros regulares. Solo existen cinco figuras geométricas regulares aplicables en 3D , o sus aproximaciones, los denominados t-desings. Estos diseños t deben cumplir que t ≥ 2N + 1 (siendo N el orden).

Tabla 3 - Los cinco poliedros regulares existentes

TETRAEDRO OCTAEDRO HEXAEDRO ICOSAEDRO DODECAEDRO

Dibujo

L (esquinas)

4 6 8 12 20

t-desing 2-design 3-design 3-design 5-design 5-design

Para crear configuraciones con diferente número de altavoces (más o menos esquinas), es posible usar poliedros no regulares geometricamente, los cuales hay que aproximar a la regularidad mediane una regla matemática.


14

Para el proyecto Sonorizart3, la esfera se va a simular con un poliedro de 24 esquinas (el mismo número de altavoces), un 7-design. Contará con un diámetro de 2.8 metros.

El diseño de la estructura se va a realizar dividiendo la esfera en seis gajos, para poder transportarla y montarla con facilidad. Se creará mediante tubos, para tener una estructura ligera y poder llegar con el cableado fácilmente a cada altavoz. Para poder acomodar los 24 altavoces, se ha estudiado implementar cuatro barras perimetrales horizontales en altitudes que permitan anillar los dispositivos de reproducción en la posición correcta (las esquinas del 7-design). Se ha añadido una barra perimetral central para mejorar la estabilidad de la estructura (ver figura 10).

Como se puede apreciar en la figura 10, se han creado seis gajos idénticos, y se han dibujado (en rojo) los altavoces en su posición correcta. El cableado se ha estudiado para que circule por los tubos marcados en rojo. La entrada a la esfera se hará desplazando los tubos marcados en azul.

3.6. DECODIFICACIÓN

Se parte de una señal f(θ, t) codificada mediante señales Ambisonics de orden N, ∅N(t), donde θ es el vector unitario que señala a un punto en la superficie de una esfera en la posición definida por ϕ y δ.

Figura 9 - Esquema del 7-desing implementado en el proyecto Sonorizart3

Figura 10 - Esfera diseñada para el proyecto Sonorizart3


15

f (θ, t) = yNT (θ) ∅N(t) Ecuación 8

Donde yNT (θ) es un vector columna con todos los componentes yN

T (θ)=[ Y00(θ),

Y0-1(θ), …, YN

N(θ) ]T. Es decir, contaremos con una columna con tamaño igual al

número de armónicos esféricos.

Para decodificarla se necesita una matriz de decodificación D. Esta matriz se crea con la configuración espacial que tienen los altavoces, teniendo en cuenta los ángulos en los que están situados. Para cada orden y número de atavoces esta matriz variará de tamaño. Las señales que finalmente se dirigirán a cada altavoz se obtienen mediante la multiplicación de ∅N(t) con la matriz de decodificación D y una matriz de pesos aN, por lo que el número de columnas de la señal codificada debe ser igual al número de filas de la matriz de decodificación; efectivamente de tamaño igual al número de armónicos esfericos. Dichos armónicos están definidos en las direcciones de los altavoces θ1, θ2, …, θL.

D = √4π

L [yN

(θ1), …, yN(θL)]T

Ecuación 9

* Para matrices D en dos dimensiones, debe usarse el término √2π

L en

decremento de √4π

L

Finalmente, se obtienen las señales de salida 𝑙i (ecuación 10). Se puede calcular también la ganancia g para una determinada señal proveniente de una dirección θs (ecuación 11):

𝑙i = D diag{aN} ∅N(t) Ecuación 10 g = D diag{aN} yN(θs) Ecuación 11

Las siguientes ecuaciones muestran dos ejemplos de creación de matrices de decodificación sencillos para disposiciones de L altavoces. La ecuación 12 crea una matriz de decodificación de escenas de primer orden en dos dimensiones (tres componentes) y la ecuación 13 para escenas en B-format (cuatro componentes). Se

multiplica por un coeficiente de valor 1

2 por el patrón cardioide de grabación.

[

Sφ1

⋮SφL

] = 1

2 [

1 cos (φ1) sin (φ1)⋮ ⋮ ⋮1 cos (φL) sin (φL)

] [WXY]

Ecuación 12

D


16

[S1

⋮SL

] = 1

2 [

1 θ1TθX θ1

TθY θ1TθZ

⋮ ⋮ ⋮ ⋮1 θL

TθX θLTθX θL

TθX

] [

WXYZ

] = 1

2 [

1 θ1T

⋮ ⋮1 θL

T] [

WXYZ

]

Ecuación 13

Esta forma de creación de decodificadores se extiende a todos los ordenes y configuraciones de altavoces, aumentando el número de componentes conforme se sube de orden. Esta técnica de presentación de señales Ambisonics le permite adaptarse a diversas configuraciones de forma relativamente sencilla.

3.7. BINAURALIZACIÓN

Disponer de configuraciones de reproducción con un número de altavoces como el del apartado anterior no suele ser frecuente en el día a día. Por ello parece lógico poder aplicar esta tecnología a dispositivos de uso más normalizado como pueden ser los ariculares. El proceso de conversión a dos canales, cuando lleva asociado la transformación que sufre el campo sonoro al interactuar con el torso y cabeza de un oyente, se denomina binauralización

Una forma de obtener sonido binaural es grabar escenas con dos micrófonos posicionados en los oídos de una cabeza artificial simulando ser los oídos de una persona. Las señales recibidas se codifican de forma que la grabación del micrófono de la oreja derecha sale por el canal derecho (R) y el de la oreja izquierda por el canal izquierdo (L).

Típicamente, la binauralización de una escena Ambisonics involucra las denominadas HRIRs (Head-Related Impulse Response o Respuestas al Impulso Relacionadas con la Cabeza) o HRTFs (Head-Related Transfer Function o Función de Transferencia Relacionada con la Cabeza). Las HRTFs son funciones de transferencia que caracterizan como un oído recibe el sonido, el cual es transformado a medida que interactua con el cuerpo del oyente y se intorduce en el canal auditivo.

Una alternativa más versátil considera la separación entre la dependencia con la sala (RIR) y la dependencia con la cabeza del oyente (HRIR). Una implementación eficiente requiere la medida de un RIR para Ambisonics de Primer Orden (ARIR) con un micrófono tetraédrico. Para realzar la resolución de ARIR se debe obtener una descomposición del espacio Ambisonics (ASDM, Ambisonic Spatial Decomposition Method), utilizando estimaciones de direcciones instantáneas. ASDM permite la renderización dinámica en altos órdenes de Ambisonics, permitiendo el uso tanto de cabezas artificiales o HRIRs individuales [3].

D


17

4. JUCE FRAMEWORK [4]

JUCE es un marco de aplicación de código abierto multiplataforma escrito en lenguaje C++. Su uso es muy extendido para el desarrollo de aplicaciones móviles y de escritorio. El objetivo de JUCE es poder crear código capaz de ser compilado y ejecutado en diferentes plataformas: Windows, Mac OS, Linux… Además de proporcinar su propio entorno de desarrollo, llamado Projucer, admite una gran variedad de IDEs y compiladores (Visual Studio, XCode, GCC…).

Para la creación de cualquier aplicación o plugin, JUCE genera un proyecto básico con diferentes scripts, funciones y módulos. Partiendo de esta base se deben añadir módulos, librerias y funciones dependiendo de las necesiades de cada trabajo; creando así proyectos propios. Gracias a todas las opciones y bibliotecas que ofrece, ha tenido mucho éxito en el campo de aplicaciones y plugins relacionados con el procesado del sonido y la música. Este framework se toma ya como un estándar para este tipo de desarrollos en código abierto, gracias a que se puede ejecutar y modificar en cualquier entorno de trabajo.

4.1. ESTADO DEL ARTE

Son varios los grupos de investigación acústica que desarrollan plugins relacionados con el audio espacial. Entre ellos, destacan el Instituto de Música Electrónica y Acústica IEM (Austria) y el Laboratorio de Acústica de la Universidad de Aalto (Finlandia). Ambas entidades proporcionan paquetes con una gran variedad de plugins, todos ellos de código abierto tanto para uso académico como personal o profesional.

IEM ofrece en su Plug-in Suite una amplia gama de codificadores (MultiEncoder, StereoEncoder, RoomEncoder), decodificadores (AIIRADecoder, BinauralDecoder, ProbeDecoder) y visualizadores (EnergyVisualizer) de señales Ambisonics; así como compresores, delays, reverbs…

El Laboratorio de Acústica de la Universidad de Aalto dispone de SPARTA (Spatial AudioReal-time Applications), una colección de plugins VST para la producción,

Figura 11 - StereoEncoder y AIIRADecoder, de IEM Fuente: [7]


18

reproducción y visualización de audio espacial: sparta_ambiBIN, sparta_ambiDEC, sparta_ambiENC, compass_binaural o compass_decoder entre otros.

El estado del arte respecto al tema que se aborda en este Trabajo Fin de Grado (crear una aplicación de generación y reproducción de escenas Ambisonics) resulta ambiguo, ya que existen plugins que, por separado, proporcionan la codificación, manipulación y decodificación de escenas sonoras; pero requieren de una Estación de Trabajo de Audio Digital (EADs o DAWs como Reaper, Cubase, ProTools…) para poder trabajarlas.

La obligatoriedad de tener que usar programas de segundos, con una curva de aprendizaje lenta, requiere tener conocimientos de los mismos para poder crear trabajos propios de calidad. Para productores musicales o ingenieros de sonido con conocimientos puede resultar una tarea tediosa (se deben encadenar y enrutar bien los diferentes plugins) pero nada compleja y con buen resultado. Sin embargo, para grupos de música que quieran ofrecer creaciones diferentes introduciendo el audio espacial, o un público general al que el audio espacial le llega habitualmente con el término popular de sonido en 8D y se le quiera introducir en la creación y manejo de escenas esto resulta un hándicap.

Por ello, una aplicación sencilla e intuitiva que permita crear escenas y paisajes sonoros tridimensionales y reproducirlas de forma binaural parece una buena forma de atraer a un público diferente y facilitar las creaciones musicales innovadoras. Además, poder percibir la espacialidad antes de tener que visitar la configuración con 24 altavoces permite trabajar a los creadores musicales con total independencia.

En la actualidad existen trabajos que permiten crear espacios sonoros, haciendo uso de diferentes técnicas (principalmente VBAP, Vector Base Amplitude Panning [5], y síntesis binaural), pero de una forma bidimensional. Además, estos deben ejecutarse en entornos de trabajo por lo que no son accesibles a cualquier público.

Es el caso del proyecto SCENA de Ana Valencia y el Grupo de Acústica de la Universidad Pública de Navarra, el cual permite colocar fuentes virtuales alrededor de un oyente y generar espacialidad sonora mediante VBAP o síntesis binaural. Las representaciones son en dos dimensiones y el programa debe ejecutarse en Matlab [6].

Figura 12 - AmbiENC y AmbiDec de SPARTA Fuente: [16]


19

4.2. LA APLICACIÓN

Como se ha descrito en anteriores apartados, la aplicación debe ser sencilla, intuitiva y con mucha usabilidad. Por ello, se ha intentado simplificar al máximo el proceso de generación de las escenas o paisajes sonoros y se ha buscado crear una interfaz donde se pueda tener toda la información necesaria para manejar las creaciones.

La aplicación da la oportunidad de diseñar una escena o paisaje sonoro desde cero, o cargar una creada perviamente; ya que se pueden guardar las características de las creaciones en un archivo json para poder usarlas en cualquier momento. Las escenas o paisajes a generar pueden contar con hasta ocho pistas de sonido diferentes. Estas deberán ser archivos wav de dos canales, de una misma duración y estar codificadas de la misma manera (tener la misma tasa de bits). Para una buena identificación de cada sonido, es obligatorio dar un nombre y un color a cada uno de ellos. Además, se da la opción de adjuntar una imagen (en formato png) a cada pista, así como introducirles una posición inicial en la escena. Estos dos campos no son

Figura 13 - SCENA FUENTE: [6]


20

obligatiorios, por lo que si no se rellenan se coloca una imagen y/o posición por defecto.

Una vez creada o cargada la escena, la ventana principal de la aplicación muestra todo lo necesario para jugar con ella. Cuenta con una simulación del campo sonoro que trasmite una sensación esférica para poder visualizar la colocación de cada fuente sonora, mostradas con un círculo de su color y la primera letra de su nombre. Otra parte importante son los controles de posición. Cada pista cuenta con tres controles rotatorios para poder modificar en tiempo real el acimut, la elevación y la distancia a la que se encuentra la fuente sonora. Todos estos controles se pueden manejar con el dispositivo MIDIMix de AKAI o, simplemente, con el ratón. La zona de controles se puede intercambiar con la zona de selección de dispositivo de audio. La parte inferior de la ventana se dedica a la reproducción y cuenta con los botones de play, pause y stop.

La escena se puede reproducir mediante auriculares, configuración de 8 altavoces (creando un círculo de radio 1.4 metros y colocados cada 45°, según la distribución del Laboratorio de Acústica de la UPNA) o en la futura instalación esférica del proyecto Sonorizarte.

Para la creación de la aplicación se han tomado como base y usado partes de código de los plugins de IEM MultiEncoder, StereoEncoder y BinauralDecoder, las cuales se nombran en este documento cuando así ocurre [7].

4.3. ORGANIZACIÓN DEL CÓDIGO

JUCE marca la carpeta Source como el lugar a guardar el código creado para la aplicación. Dentro de dicha carpeta, se han creado dos scripts por cada posible ventana (la cabecera con extensión .h, y el cuerpo con extensión .cpp), el script Main.cpp (encargado de lanzar la aplicación), los scripts Artist.cpp y Artist.h (contiene objetos tipo artista, uno por cada sonido de la escena) y Sphere.h (para la recreación de la esfera). La creación de una ventana necesita dos clases: la que crea la ventana y la que introduce el contenido en ella. Ambas clases se inicializan en el mismo script.

En el Anexo 1 se muestra una relación de scrpits, clases, ventanas y funciones.

Los recursos, imágenes y datos necesarios se reparten en las siguientes subcarptetas:

− Decoding: contiene el archivo json con las matrices de decodificación necesarias.

− Images: contiene las imágenes que se usan en la aplicación; iconos para los botones play, pause, y stop, configuraciones de salida y búhos para las diferentes vistas.

− IRs: contiene las respuestas al impulso necesarias para la binauralización. Son 7 archivos wav, uno para cada orden Ambisonics. Los archivos han sido obtenidos de la plugin suite de IEM [7].


21

− Resources: contiene los scripts que han sido adoptados de otros proyectos de código abierto. Los archivos han sido obtenidos de la plugin suite de IEM, en el próximo apartado se hace referencia a cada uno de ellos [7].

4.4. ESTADOS DE LA APLICACIÓN

La aplicación tiene tres estados: bienvenida (1), carga o creación de una escena (2) y manejo de la escena (3). Se navega por ellos de froma 1→2→3.

4.4.1. ESTADO 1

El primer estado comienza al ejecutar la aplicación. Este permanece a la espera de la selección que se haga en la interfaz: cargar una escena ya existente o crear una nueva. Una vez seleccionado el botón correspondiente, pasa al segundo estado.

4.4.2. ESTADO 2

El segundo estado tiene dos apartados, dependiendo de la selección hecha en el estado anterior (cargar o crear). Independientemente del apartado, permite

ESTADO 3ESTADO 2ESTADO 1

Selección entre cargar o crear

una escena

Búsqueda de una escena ya

existente

Creación de una escena con hasta ocho elementos

Manejo y reproducción de

la escena

Diagrama 1 - Diferentes estados de la aplicación

Figura 14 - Árbol de carpetas del proyecto


22

introducir la información necesaria para la escena sonora. Dicha información es filtrada y ordenada antes de pasarla al estado final. Si encuentra datos erróneos o indicios de archivos corruptos (a baja escala), no deja pasar de estado.

4.4.3. ESTADO 3

El tercer estado reproduce y permite modificar la escena. Trabaja en varios aspéctos simultáneamente, siendo el más costoso e importante la codificación y reproducción del audio:

− Calcula la señal Ambisonics y la reproduce instantáneamente en la configuración de altavoces indicada. Para una salida mediante auriculares la binauraliza, y para las salidas de 8 y 24 altavoces la decodifica con la matriz correspondiente.

− La reproducción se puede parar, reanudar y llevar al inicio (play, pause y stop).

− Cualquier cambio de posición en un elemento es dibujado, tanto si es accionado con el MIDIMix o con el ratón.

− Permite cambiar la vista de la esfera, y redibuja los elementos en las coordenadas correspondientes.

− Permite cambiar y ver la configuración del dispositivo de salida.

− Permite cambiar la configuración de altavoces de salida, siempre y cuando la capacidad de la interfaz de audio lo permita.

− Cada medio segundo, calcula el gasto de CPU y busca el dispositivo de salida de audio en uso. Muestra ambos datos por pantalla.

− Permite guardar la escena en curso, manteniendo las posiciones actuales.

Una vez finalizado este estado, la aplicación se cierra.

4.5. VENTANAS

Es importante diferenciar los estados en los que se encuentra la aplicación, y por tanto, las diferentes ventanas con las que cuenta. En el segundo estado, por ejemplo, se dan dos tipos diferentes de ventanas, pero se mantiene el mismo estado.

La aplicación puede mostrar cinco ventanas diferentes, aunque en un proceso normal solo se verán tres, dependiendo del camino escogido. En este apartado se explica detalladamente el contenido de cada una de ellas. Para un buen entendimiento, las ventanas serán nombradas con un formato x.y, donde x es el estado del programa e y el número de ventana. Así, la ventana de bienvenida es la 1.1, la de carga 2.2, la de creación 2.3 y la ventana final del manejo de escenas 3.4.

4.5.1. VENTANA 1.1: Bienvenida

La ventana inicial o de bienvenida es una simple interfaz con dos botones: uno para cargar una escena ya creada (Load scene) y otro para crearla desde cero


23

(Create scene). Se deberá seleccionar una de las dos opciones para poder avanzar al siguiente paso: si se pulsa Load scene, se llama a la creación de una ventana tipo 2.2, si por el contrario se pulsa Create scene, se crea una ventana tipo 2.3.

4.5.2. VENTANA 2.2: Cargar una escena existente

La ventana para cargar una escena ya existente es una interfaz de búsqueda y descripción de ficheros. Cuenta con una barra de búsqueda y un apartado donde se describe la selección. Una vez cargado el archivo, se puede pulsar el botón Load para cargar la escena y crear una ventana tipo 3.4.

Si el programa detecta que el archivo es fraudulento, o hay algún error en su lectura, lanza una ventana de alerta (ver apartado 4.5.5) y detiene el proceso.

Figura 15 - Ventana 1.1


24

4.5.3. VENTANA 2.3: Crear una escena

La ventana para crear una escena permite introducir todos los datos necesarios para incorporar un elemento o sonido en la escena. La interfaz es interactiva y capaz de crear y eliminar componentes, dependiendo del número de elementos que se quieran introducir. Inicialmente aparecen los campos para un único elemento, y cuenta con botones para añadir (y eliminar) elementos ad hoc. Los datos a introducir son el nombre, un color y una ruta al archivo de sonido. Opcionalmente se puede dar la posición inicial y una ruta para el icono.

Cuando se pulsa el botón Create, se crea una ventana tipo 3.4. Si se detecta algún campo obligatorio sin rellenar, se lanza una ventana de alerta (ver apartado 4.5.5) y se para la creación. En el caso de los campos no obligatorios, se inicializan con valores por defecto.




25

4.5.4. VENTANA 3.4: Reproducción y manejo de la escena

La ventana final del programa es la que ofrece mayor interactividad. Está dividida en cuatro zonas para potenciar su usabilidad:

1. Una cabecera con el nombre del programa, información sobre la salida y entrada de datos, un botón para guardar la escena y un botón para seleccionar la configuración de altavoces.

2. Un panel que reproduce el área alrededor del oyente como si fuera una esfera. En él se dibujan todos los elementos de la escena y se actualizan en cada movimiento. Además, tiene la opción para seleccionar la vista de la esfera: frontal, lateral o superior.

3. Un panel que muestra el nombre, el icono y los controles para mover los elementos, en forma de sliders rotatorios. Tiene tres controles para cada sonido (acimut, elevación y distancia) y dos botones para silenciar o ponerlo en solo. Se dibujan tantos como elementos existen. La vista de los controles se pueden alternar con un selector de salida de audio gracias a los botones laterales TRACKS y SETUP.

4. Un pie de ventana con los controles básicos de reproducción en forma de botón: play, pause y stop.



26

4.5.5. Ventana de alertas

Las ventanas de alerta se generan cuando se detecta algún error en el transcurso del programa. Cada una se personaliza con la información del error que la ha causado y bloquean la ventana desde la que se ha lanzado. Tanto el botó OK como Cancel, cierran la ventana y permiten seguir con el programa.

4.6. DESCRIPCIÓN DE SCRIPTS Y FUNCIONES

4.6.1. Main.cpp

La clase SceneCreatorVisualApplication se encarga de ejecutar e iniciar la aplicación, creando una ventana tipo WelcomeWindow (la ventana 1.1). Dicha ventana se llena con la clase Welcome.

4.6.2. Welcome.cpp / Welcome.h

La clase Welcome es llamada desde Main.cpp para pintar la ventana de bienvenida. Cuenta unicamente con dos botones tipo TextButton: Load scene y Create scene. Si se selecciona el botón de cargar escena se crea una ventana tipo LoadWindow. Por lo contrario, si se presiona el botón de creación de escena, se crea una ventana tipo CreateWindow.

Al tener una función sencilla, no se ha creado un listener y desencadenan sus acciones directamente con el comando onClick.

Figura 19 - Ventana de alerta

Diagrama 2 - Flujo de Main.cpp


27

4.6.3. Load.cpp / Load.h

La clase Load es llamada al crear una ventana tipo LoadWindow desde la ventana de bienvenida. Dibuja un simple buscador de archivos, compuesto por una barra de búsqueda con botón, un cuadro donde aparece la descripción del archivo y un botón para cargar la escena y continuar al siguiente paso.

Para ello crea cuatro tipos de componentes: dos TextEditors (la barra de búsqueda y el cuadro de descrición) y dos TextButtons (el de búsqueda y el de carga). Ambos cuadros de texto son solo de lectura, por lo que no se puede escribir en ellos. El botón Load solo se activa si el archivo cargado es correcto.

El botón de búsqueda llama a la funcón openBrowser, creando un componente FileChooser. Este es el encargado de abrir la ventana de búsqueda nativa del dispositivo, donde solo se podrán buscar archivos tipo json. Una vez seleccionado, se escribe la ruta escogida en el cuadro de búsqueda y se pasa el archivo a la función parser.

La función parser es la encargada de leer el archivo y escribir toda la información en el cuadro de descripción. Si ocurre algún problema en la lectura crea una ventana de alerta; al igual que si no encuentra el campo ‘Elements’ dando el archivo por corrupto y parando el avance. Para escribir en el cuadro de descripción, se usa la variable descriptor, de tipo string. La información se va concatenando para crear un texto legible y, finalmente, se escribe en el cuadro y se activa el botón Load.

Diagrama 3 - Flujo de la clase Welcome


28

Una vez presionado Load, se crea una ventana tipo MainWindow, y se da paso a la recreación de la escena.

Diagrama 4 - Flujo de la clase Load


29

4.6.4. Create.cpp / Create.h

La clase Create es llamada al crear una ventana tipo CreateWindow desde la ventana de bienvenida. Inicialmente dibuja un único contenedor para introducir la información de una fuente de sonido, los botones - y + para añadir o quitar fuentes y el botón Create. Cada contenedor se cuenta como un elemento de la escena, es decir una fuente sonido. Se les puede añadir la siguiente información:

− Nombre. Obligatorio.

− Color. Obligatorio.

− Posición inicial, visto como acimut, elevación y distancia. No es obliatorio, se inicializarán en la posición (0, 0, 1.5).

− Ruta al archivo de sonido. Obligatorio.

− Ruta a la imagen del sonido. No es obligatorio, se inicializará con la foto de un búho con auriculares.

Un contenedor tipo cuenta con los siguientes componentes: seis TexEditors (nombre, acimut, elevación, distancia, ruta al sonido y ruta a la imágen), un ComboBox (para la selección del color) y dos TextButtons (para buscar los archivos). Cada uno de los componentes se almacenan en un array para poder eliminarlos con mayor facilidad y se añaden como hijos de la clase Create.

Los componentes para el nombre, el acimut, la elevación y la distancia son de escritura y se deben introducir con el teclado. Los de las rutas son solo de lectura, y no se puede escribir en ellos.

La selección del color se hace con el componente ComboBox, un desplegable que muestra los colores disponibles. Si un color ha sido marcado en fuentes de sonido anteriores se deshabilita, esto se consigue guardando el estado de cada color en un array y con la función coloursMenuChanged. Al seleccionar un color, cambia su estado a true y escribe el color en el ComboBox. Los estados se actualizan en el array de booleanos enabledColours. La lista de colores está almacenada en la enumeración boxColours, en los datos privados de la clase.

Por otro lado, la búsqueda de los archivos se hace con los dos botones disponibles. Cuando se presionan, llaman a la función chooseButtonClicked y le pasan el cuadro de texto del que provienen. La llamada se hace mediante la propiedad onClick. Esta función lanza un componente de búsqueda FileChooser, y dependiendo del botón del que provenga la llamada permite la busqueda de wavs (para el archivo de sonido) o de imágenes png (para el icono). La ruta se escribe en el cuadro de texto que ha recibido la función.

Gracias a los botones -/+ dibujados en la esquina inferior izquierda del último contenedor disponible, se pueden añadir o quitar fuentes de sonido (con un máximo de ocho y un mínimo de una). El botón para quitar elementos solo se activa si hay dos o más, y el de añadir se desactiva al llegar al número máximo (8). La función encargada de manejar ambos botones es buttonClicked. Dicha función añade o resta el número de elementos y elimina o crea los componentes de los contenedores necesarios.


30

Para crear contenedores, se llama a la función elementAdder. Esta crea y visibiliza todos los componentes y los añade a sus respectivos arrays. La eliminación se hace desheredando cada componente y borrándolos de sus arrays.

Finalmente, al presionar el botón Create, se llama a la función createJSON. La función recorre cada contenedor componente a componente. Si los obligatorios están sin rellenar, lanza una ventana de aviso e interrumpe la creación. Si encuentra las posiciones vacías inicializa a 0 acimut y elevación y a 1.5 la distancia; así como la imagen que es rellenada como default.

Una vez añadido al json toda la información, se crea una ventana MainWindow.

Diagrama 5 - Flujo de la clase Create (I)


31

4.6.5. MainComponent.cpp / MainComponent.h

La clase MainComponent es el núcleo del proyecto y es por ello la más compleja y extensa. Es llamada al crear una ventana tipo MainWindow, ya sea por el camino de creación o de carga de una escena. Para poder crearla, es necesario pasarle el archivo json con la información de la escena. Este debe ser creado o estar almacenado con anterioridad.

La información es recibida en el constructor como una variable. El primer paso que hace es leer el archivo para tener todos los datos y poder dibujar la vantana. Para ello se usa la función parser, encargada de crear los elementos en forma de artistas con la información correspondiente. Si la lectura es correcta, la función sigue los siguientes pasos:

1. Guarda el campo ‘Elements’ en la variable global del programa elements. Esta variable marcará en todo momento cuantos elementos tiene la escena.

Diagrama 6 - Flujo de la clase Create (II)


32

2. Para los ocho elementos posibles, lee los cinco campos que deben tener: nombre, color, posición, ruta al archivo de sonido y ruta a la imagen.

3. Si el nombre recibido es un string vacio, es decir ese elemento no existe, no creará el elemento al que le corresponde. Así, solo se crearán artistas hasta el número de elementos de la escena.

4. Para crear cada elemento, se filtra la posición por seguridad: el acimut y la elevación deben estar entre 0 y 360, y la distancia entre 1.5 y 12.0; si se exceden de esos valores, se reescriben al mínimo o máximo más cercano.

5. Con cada grupo de datos, se crea un nuevo artista y se introduce en el array global newArtists, el ID del color se guarda en el array colourIds, ya que es más fácil manejar números que colores.

Una vez rellenado el array newArtists con todos los elementos de la escena, se comienza a tratar los datos. Para ello, primero hay que crear la interfaz donde aparece la información.

La disposición de la interfaz es generada mediante un grid, una especie de cuadrícula para poder organizar mejor la visualización. Dicha cuadrícula se crea dividiendo la ventana en filas y columnas y se implementa en la función para pintar la ventana paint. Con esta técnica se han creado cuatro espacios diferentes: cabecera (header), panel principal (mainPanel), zona de interacción (demode) y pie de ventana (footer).

HEADER

MAIN PANEL DEMODE

FOOTER

Figura 20 - Grid de la interfaz

Para poder crear la disposición (figura 20), se crean tres filas y dos columnas. El tamaño de cada columna y fila se marcan como múltiplos de un tamaño unidad. En este caso, la cabecera y el pie tienen altura unidad y el panel principal y demode una altura 8 veces mayor. La anchura de las columnas es de 6 contra 4. Para extender la cabecera y el pie a todo el ancho, se expanden a ambas columnas.

La forma de dibujar en este tipo de configuración es diferente a la de las ventanas anteriores: se crea una estructura por cada espacio, y se dibujan


33

independientemente. Es necesario desarrollar cuatro estructuras (un tipo de componente llamado struct) diferentes, una para cada zona del grid. Son creadas en la cabecera de la clase (MainCompnent.h) como componentes privados. Las estructuras básicas cuentan con las funciones típicas de una clase: constructor, paint y resized, pero se les puede añadir más así lo requiere el proyecto. Se han creado las sigueintes estructuras:

− Header: la cabecera contiene un texto con el nombre de la aplicación en el centro. En la zona derecha, está el botón para guardar las escenas y el botón de cambio de configuración de altavoces. En la zona izquerda se lee en tres campos de texto diferentes el canal de salida en uso, la conexión con el MIDIMix y el gasto de CPU que se está haciendo.

− MainPanel: el panel principal contiene la escena, la simulación de la esfera. Además, en la parte baja izquierda se dibujan tres botones para poder hacer el cambio de vista. La esfera se crea con el componente desarrollado en Sphere.h.

− Demode: la zona de interacción contiene el nombre de cada elemento, su icono correspondiente, los tres controles tipo slider (acimut, elevación y distancia) y los botones de solo y mute. Esta información se puede alternar con el apartado de selección de dispositivo de salida mediante los dos botones del lateral.

− Footer: el pie de ventana contiene los botones de reproducción play, pause y stop.

Para la cabecera, la zona de interacción y el pie de ventana, se crean los componentes en el constructor de la clase (MainComponent) y se añaden como hijos a las estructuras correspondientes. En el caso del panel principal, los componentes se crean en el script Sphere.h, el cual ha sido creado a partir de la adecuación de SpherePanner.h, disponible en los recursos de la plugin suite de IEM [7].

El tamaño de los componentes es aplicado de forma fija en MainComponent, en relación al tamaño inicial de cada estructura, ya que la ventana es de tamaño fijo (no permite modificaciones) y no podrá variar las dimensiones.

HEADER

En la estructura de la cabecera se ha desarrollado la función setInfo, además del constructor y paint. La nueva función se usa para poder cambiar los textos de la parte izquierda (Output –A–, MIDIMix –B– y CPU –C–). Dicha función añade al texto fijo el string que se le pasa, y repinta la cabecera para que aparezcan los cambios. Los dos botones de la zona derecha son creados en MainComponent y añadidos como hijos.

El botón SAVE –F– es un componente TextButton. Al pulsarlo, mediante la propiedad onClick, se llama a la función saveFile para guardar los datos de la

A B C

D E F

Figura 21 - Header con leyenda de apartados


34

escena. La función crea un objeto tipo DinamicObject en el que se introducen todos los datos del array newArtists en forma de propiedades. El objeto es convertido a json y se abre una ventana (componente FileChooser) para seleccionar la carpeta y el nombre. Generalmente, un FileChooser es usado para buscar archivos; para poder seleccionar una carpeta e introducir el nombre, se marca su propiedad browseForFileToSave a true.

Respecto al botón para seleccionar la configuración de altavoces de salida –E–, es creado en el script de cabecera para poder cambiar su imagen: cuando se este en modo auriculares, se dibuja un icono de auriculares; en modo laboratorio, un altavoz y en modo esfera, una esfera. Así se puede saber en cualquier momento la configuración que se está usando. Como la aplicación se inicia por defecto en modo auriculares, el botón aparece con dicho icono.

Cuando se hace click sobre él (propiedad onClick), se llama a la función

openPopup, encargada de crear un menú desplegable con las tres opciones disponibles. El menú es creado con un componente PopUp, al que se le añaden los apartados Headphones, 8 loudspeakers y Sphere. Dichos apartados solo se activarán (y serán seleccionables) si se detectan las suficientes salidas de audio disponibles. Una vez hecha la selección, cambia la imagen del boton a la correspondiente, manda repintar la cabecera y se actualizan las variables isHp de la esfera y outMode, que tiene tres estados disponibles: headphoneConfig (auriculares), labConfig (8 altavoces) y sphereConfig (esfera).

El título que aparece en el centro del header –D– es dibujado en la función paint de la estructura.

Figura 22 - Iconos utilizados para el botón de configuración

Figura 23 - Desplegable para cambiar la configuración de salida. En este caso, solo hay disponibles dos salidas, por lo que la única configuración posible es auriculares


35

MAIN PANEL

A la estructura del panel principal se le añade un componente esfera –B– creado en Sphere.h desde MainComponent. Dicho componente implementa también los botones para los cambios de vista –A–. Dependiendo de la configuración de salida en uso, los búhos se dibujan con auriculares (modo headphoneConfig) o no (modos labConfig y sphereConfig)

Lo importante en esta zona es conseguir la impresión de un espacio tridimensional. Para conseguirlo, se juega con el tamaño de los elementos y su posición respecto al búho central.

La creación de la esfera y los botones se explica en el siguiente apartado (4.6.6), ya que corresponde a otro script.

Figura 24 - Main panel con leyenda de apartados

A

B

Figura 25 - Vista de MainPanel en configuración sin auriculares


36

DEMODE

La estructura Demode cuenta con dos posibilidades: vista de los controles de cada elemento y vista de la configuración de salida del audio, las cuales se pueden alternar gracias a los botones de la parte derecha –F–. Ambos botones son tipo TextButtons y, en este caso, están creados directamente en la estructura, para facilitar el manejo de los hijos.

Para visibilizar y ocultar los componentes –B, C, D y E–, se recoge el array de todos los hijos disponibles: si se selecciona el botón TRACKS, se visibilizan los componentes de los elementos y se oculta el panel AudioSetup, y viceveresa. Para pintar los nombres de cada elemento –G–, los iconos –A– y los rectángulos que los contienen se ha creado la variable booleana isTracks. Esta es puesta a true si se selecciona TRACKS, y a false si se selecciona SETUP. Así, en la función paint se da la orden de pintar los datos (o no) con un condicional.

Como se aprecia en la figura 26, todos los elementos tienen los mismos componentes: dos botones (solo y mute) y tres sliders rotatorios; creados con un bucle for. Sus posiciones y tamaños se calculan dependiendo del número de elementos existentes:

− Los botones de solo y mute –B– son componentes tipo TextButton. Se inician en estado apagado y con un color de fondo semitransparente (propiedad

F B

A

C D E

G

Figura 26 – Demode con leyenda de apartados, vista de controles de elementos


37

setColour). La trasparencia se quita al pulsarlos y pasar su estado a encendido. Los dos botones de cada elemento se agrupan para que no pueden estar ambos activos a la vez. Para manejar todos los botones de este tipo, se les añade el listener que proporciona su propia clase. Cuando son pulsados, se llama a la función buttonClicked, la cual sabe desde que botón se ha llegado a ella. La función cambia el estado del botón, así como el del elemento correspondiente. Además, si se llega desde un botón de solo, se desactivan el resto de elementos y activa sus botones de mute. El estado de los botones es almacenado en los arrays soloButtons y muteButtons.

− Los silders de posición –C, D, E– son componentes Slider, de estilo rotatorio. Se les da un color a cada uno de ellos (acimut azul, elevación rojo y distancia verde) para una mejor diferenciación. Su valor inicial lo marcan los datos disponibles en el array newArtists. A los sliders de acimut y elevación se les da un rango de 0 a 360 (grados) con precisión unidad y al de distancia de 1.5 a 12.0 (metros) con precisión decimal. Se muestra debajo de ellos una caja con el valor y se les añade el listener que proporciona su clase. Al ser modificados llaman a la función sliderValueChanged. Esta se encarga de leer la nueva posición y actualizarla en los elementos. Los sliders son almacenados en los arrays azimutSliders, elevationSliders y gainSliders.

Las imágenes no cuentan como componentes ya que se dibujan directamente en la estructura, y sus posiciones (al igual que las de los nombres y rectángulos) también se calculan dependiendo del número de elementos de la escena.

El panel de selección de dispositivo de audio se genera con el componente AudioDeviceSelectorComponent. Permite seleccionar el dispositivo de salida, el driver a usar, el número de salidas, la frecuencia de muestreo y la longitud del buffer. Se ha desactivado la selección de dispositivo MIDI, ya que unicamente se ha implementado el dispositivo MIDIMix de AKAI y la conexión con él es automática. Los cambios se hacen al instante en el programa y la reproducción, pero se deben tomar ciertas precauciones:

− La aplicación acepta cualquier dispositivo que disponga de 0 a 256 salidas y entradas de audio. Aun así, solo intentará abrir 8 canales de salida (ninguno de entrada ya que no son necesarios). Cuando se implemente la esfera final se abrirán 24 canales. Si el dispositivo de audio no cuenta con 8 salidas, abrirá todas las disponibles (aunque puede que solo use dos).

− Habitualmente, se inicia con el driver del ordenador en el que corre la aplicación, pero si encuentra la interfaz Focusrite Scarlett 18i20 (usada en el laboratorio para las pruebas con la configuración de 8 altavoces) hace uso de los drivers ASIO.

− La razón de no usar los drivers ASIO desde el inicio es la siguiente: si el ordenador no tiene conectada ninguna interfaz o dispositivo que trabaje con ellos, no sabe como hacer la reproducción y da error. Por la misma razón, no se debe cambiar a un driver ASIO si no se tiene la certeza de que se puedan usar.


38

− Se debe tener cuidado al cambiar la configuración de altavoces. Si se está reproduciendo en configuración de 8 altavoces y se intenta cambiar a un dispositivo con menos salidas, hará cerrar la aplicación por falta de salidas de audio.

FOOTER

La estructura Footer es la encargada de los componentes para el manejo de la reproducción. Dichos componentes son tres ImageButtons, y permiten reproducir, parar y llevar al inicio la escena. Se crean así los típicos botones play (icono triangular), pause (icono de dos barras verticales) y stop (icono cuadrado).

Los tres botones se agrupan en el grupo número 9 (superior a los posibles grupos creados anteriormente en botones de los elementos), ya que usan el mismo listener que los botones de solo y mute y se requiere poder diferenciarlos. Cuando se pulsa sobre ellos, se llega a la función anteriormente mencionada buttonClicked. Se encarga de cambiar el estado de la reproducción a playing,

Figura 27 - Demode, vista control de dispositivo de audio

Figura 28 - Footer


39

paused o stopped y almacenarlo en la variable state. Además, al pasar el ratón encima de cada botón se iluminan y el el botón activo cuenta con más brillo.

Diagrama 7 - Flujo de la clase MainComponent (I)


40

4.6.6. Sphere.h

Este script ha sido creado a partir de SpherePanner.h, disponible en la plugin suite de IEM [7]. Su labor es crear un componente que se asemeje a una esfera, para ser dibujado en el panel principal. Para crear un espacio tridimensional en un plano bidimensional es necesario crear sensación de profundidad, y se consigue en la esfera y en los elementos. Además, es capaz de cambiar la posición desde la cual se está viendo. El componente se crea en dos partes: el fondo y los elementos.

FONDO

El fondo se encarga de las partes fijas del plano. Es decir, la simulación de la esfera y las etiquetas de posición. Se crea en la clase SphereBackground, a la que se le han añadido ciertas modificaciones para integrarlo en la aplicación, y se incorpora al panel principal cuando se crean los elementos.

Diagrama 8 - Flujo de la clase MainComponent (II)


41

Las etiquetas de posición no son del todo fijas, ya que se actualizan al cambiar de vista. Estas marcan donde están los lados, el frente y la trasera, y la parte de arriba y abajo de la esfera. En la vista superior se pintan las etiquetas FRONT, BACK, LEFT y RIGHT, mientras que en las vistas lateral y frontal se pintan OVER, UNDER, LEFT y RIGHT en sus respectivas posiciones respecto al perímetro.

La esfera es dibujada creando círculos de diferentes diámetros respecto a un mismo punto central. Dichos círculos se rellenan de color blanco, con una transparencia del 20%. Así, las zonas de los círculos que se solapan tienen una mayor solidez y dan sensación de estar más cerca. Al círculo con diámetro menor se le asigna un color lima simulando la esfera de altavoces. Dentro de él no podrá haber elementos. Se crean también los ejes por medio de líneas. Todas las posiciones y tamaños se calculan respecto al tamaño de la estructura, y teniendo en cuenta el punto central.

ELEMENTOS

Los elementos son otra de las claves para simular un espacio 3D. Se crean y manejan en la clase SpherePanner. Para su creación se implementa la clase myElement, similar a la clase Artist, y cuentan con un color, una etiqueta, un vector de coordenadas, estado de activación, radio y prioridad. Todas las propiedades cuentan con getters y setters.

Cuando se lee la información, al iniciar la ventana, se crea un myElement por cada elemento de la escena y se añade al array myElements mediante la función addMyElement. Para poder intoducir las coordenadas conforme se modifican, la función getMyElements devuelve el array, permitiendo modificar la posición de cualquier elemento con el setter setCoordinates.

La propiedad active sirve para activar o desactivar los elementos. Para la esfera esto sirve únicamente para darles color o pintarlos en gris. Un elemento gris significa que está silenciado.

En la clase SpherePanner se implementan los botones de las tres vistas disponibles. Estos se encuentran en la parte inferior izquierda, y son componentes ImageButtons creados con imágenes de búhos. El botón presionado tiene más brillo que el resto, y cuando se pasa el ratón sobre ellos se iluminan. Al seleccionar la vista deseada se llama a la función selectOwl, encargada de marcar la vista en la que se deben dibujar los elementos y el fondo de la esfera, así como seleccionar la imagen a dibujar en el centro de la representación.

Figura 29 - Iconos para las tres vistas disponibles: frontal, superior y lateral


42

Todos los componentes se dibujan en la función paint. En el centro del espacio se dibuja el icono correspondiente, asemejando una persona en el interior de la esfera. Para dibujar los elementos se hace uso de la trigonometría, consiguiendo así pasar coordenadas en tres dimensiones a las dos dimensiones que ofrecen las pantallas. Por ello, el vector de posición de cada elemento que se recibe se trata para ajustarlo al plano:

1. El acimut y la elevación (ϕ y δ) se almacenan en ángulos sexagesimales, por lo que se convierten a radianes para su uso con senos y cosenos.

2. La distancia (r), almacenada en valores que van de 1.5 a 12.0, se convierte al rango disponible (el radio de la esfera dibujada).

Para crear cada elemento se usa un componente rectangular, el cual se añade en forma de elipse para darle un perímetro circular (asemejando una bola en el espacio sonoro). Dicho componente se dibuja partiendo del centro del plano, y se le añade la compensación necesaria para situarla en su posición real. Es decir, tiene coordenadas bidimensionales. El tamaño de su área es acorde a su posición.

La compensación de la posición central es diferente en las tres vistas que se ofrecen, ya que cada una de ellas requiere una conversión de coordenadas diferente. El plantemiento se presenta para un plano con eje de coordenadas 2D X, Y (horizontal, vertical) y para una posición del elemento 3D ϕ, δ, r. La amplitud de senos y cosenos va desde -1 a 1, por lo que se multiplican por la distancia r para desplazarlos a su posición correcta.

COORDENADAS PARA LA VISTA FRONTAL

La vista frontal requiere que cuando no haya elevación el elemento se

mantenga en el eje X. Por ello, el eje Y se dibuja con un coseno de δ desfasado π

2

radianes. El eje horizontal se maneja con un seno de ϕ desfasado π radianes, encargado de mover el elemento en el eje, y se multiplica con un coseno de δ para alejarlo del eje cuando la elevación sea no nula.

Tabla 4 - Compensaciones para la vista frontal

EJE X r · sin(ϕ + π) · cos(δ)

EJE Y r · cos(δ + π

2)

COORDENADAS PARA LA VISTA SUPERIOR

Para la vista superior se usa la coordenada ϕ para marcar la posición respecto a los ejes. Usando el seno en el eje X y el coseno el eje Y desfasados π radianes, se consigue posicionar correctamente el elemento en el perímetro marcado por r. Multiplicándolos con el coseno de ϕ, se desplaza el elemento del perímetro, añadiéndole la elevación.


43

Tabla 5 - Compensaciones para la vista superior

EJE X r · sin(ϕ + π) · cos(δ)

EJE Y r · cos(ϕ + π) · cos(δ)

COORDENADAS PARA LA VISTA LATERAL

La vista lateral es una vista frontal rotada π

2 radianes hacia la derecha. Las

compensaciones se obtienen de la misma forma que en la vista frontal, introduciendo en el eje X el giro en forma de desfase. Es por ello que el desfase

del seno es unicamente de π

2 radianes.

Tabla 6 - Compensaciones para la vista superior

EJE X r · sin(ϕ + π

2) · cos(δ)

EJE Y r · cos(δ + π

2)

Para conseguir el efecto 3D anteriormente mencionado se siguen varias líneas:

POSICIÓN RESPECTO AL BÚHO CENTRAL

Dependiendo de la posición del elemento se dibuja antes o después del búho. Así, si está situado detrás no se verá y si esta delante se pintará por encima del icono. Para cada vista el condicionante para dilucidar la posición respecto al búho es diferente, ya que se debe separar la esfera por la mitad teniendo en cuenta como se está viendo en pantalla. Si la posición cumple las condiciones de la tabla 7, el elemento esta detrás del búho y por tanto se pinta antes. De lo contrario, se da por hecho que el elemento está en la parte delantera y se pinta después del búho.

En la figura 30 se muestran las franjas de separación que se consiguen. A la izquierda, el corte en la vista lateral. A la derecha, la frontera para la vista superior. El generado en la vista frontal no se aprecia en una imagen, ya que es el mismo que el lateral rotado 90° sobre su eje vertical.

.

VISTA FRONTAL ϕ ≤ 90°; ϕ ≥ 270°; δ ≤ 90°; δ ≥ 270°

VISTA SUPERIOR δ ≥ 180°

VISTA LATERAL ϕ ≤ 180°; δ ≤ 90°; δ ≥ 270°

Tabla 7 - Posiciones a cumplir para situar un elemento en la parte trasera


44

TRANSPARENCIA DEL ELEMENTO

Siguiendo con la idea anterior, cuando un elemento se encuentra en la parte trasera se transparenta su color, quedando más marcado su perímetro. Para ello se deben cumplir los condicionantes de la tabla 7.

TAMAÑO DEL ELEMENTO

El tamaño de los elementos (el área del rectángulo) varía conforme lo hace su posición. Si se encuentra cerca de la visión del usuario, tienen mayor diámetro, y empequeñecen conforme se alejan hacia el fondo. Todos los elementos parten de un diámetro fijo, el que tienen cuando se encuentran en el corte central de la esfera. Con el uso de razones trigonométricas se amplía o estrecha el perímetro.

Tabla 8 - Cálculo del diámetro de los elementos en cada vista

VISTA FRONTAL 20.0f + 6.0f · -cos(δ) · cos(ϕ)

VISTA SUPERIOR 20.0f + 6.0f · sin(δ)

VISTA LATERAL 20.0f + 6.0f · -cos(δ) · sin(ϕ)

4.6.7. Artist.cpp / Artist.h

La clase Artist funciona como creador de objetos artista. Cada fuente de sonido o elemento de una escena es tratado como un artista diferente. El objeto cuenta con todas las propiedades que se pueden introducir a la hora de crear

Figura 30 - Secciones a realizar para la posición de los elementos FUENTE: ultracoloringpages.com

Figura 31 - Técnicas para dar sensación tridimensional


45

una escena: nombre, color, posición (acimut, elevación y distancia), ruta al archivo de sonido y ruta a la imagen. También cuenta con la propiedad icono, que es la imagen ya cargada desde la ruta.

Los artistas se crean directamente con su constructor [Artist(String name, String pathIcon, String pathTrack, Vector3D<float> coor, Colour colour)] , ya sea viniendo de la vertiente de carga de escena o de creación. A la hora de crear los objetos, la ruta de la imagen se usa para cargarla y guardarla en la propiedad icon como un componente Image. Así no es necesario cargar la imagen cuando se ejecuta la ventana final. El audio no se carga como tal, se guarda solo la ruta, porque a priori no se sabe la longitud que tendrán y puede ser demasiada información a manejar. Además, se deben tener ciertos factores en cuenta a la hora de leer audios, explicados en el apartado 4.8.

Todas las propiedades cuentan con getters y setters, para poder coger y cambiar la información facilmente.

4.7. DISPOSITIVOS EXTERNOS

En lo que a comunicación y transferencia de datos con dispositivos externos se refiere, la aplicación permite la conexión con interfaces de audio externas y el controldor MIDIMix de AKAI.

4.7.1. Interfaces de audio externas

La conexión con interfaces de audio externas se hace directamente desde el panel de selección de dispositivo. La aplicación se conecta al dispositivo que esté haciendo uso el ordenador, siempre que no esté conectada la interfaz Focusrite Scarlett 18i20 (el porqué ha sido explicado en la sección demode del apartado 4.6.5). La comunicación la realiza el módulo de audio de JUCE sin necesidad de tener que crear código específico.

4.7.2. Controlador MIDI

MIDI (Musical Instrument Digital Interface) es un protocolo para la comunicación entre instrumentos musicales electrónicos con otros dispositivos. La aplicación ha sido adaptada para el dispositivo MIDIMix de AKAI, por lo que las conexiones con controladores diferentes no funcionan.

Como se puede apreciar en la figura 32, el dispositivo ofrece diversos controles. Para la aplicación solo serán útiles los botones rotatorios −A− para modificar las posiciones de los elementos y los botones marcados −B−, los cuales se usarán como mute y solo. El controlador dispone de controles para ocho canales −C−, el máximo de elementos disponibles en una escena, por lo que cada elemento se enruta a su propio canal siguiendo el siguiente orden: el primer elemento del panel se controla con el canal 1, el segundo con el canal 2 y así sucesivamente. En la figura 33 se muestra la relación entre los botones del programa y los del controlador MIDI.


46

La conexión con el controlador se hace al crear la ventana final, en la clase MainComponent. Se leen todos los dispositivos MIDI disponibles y si entre ellos se encuentra el MIDIMix, el programa se conecta a él y escribe “Connected” en su apartado del header. Si por lo contrario no da con el controlador, se manda la información “Not Found” a la cabecera.

Para crear una comunicación fluida con el dispositivo, es necesario proporcionar a la aplicación un manipulador de mensajes MIDI. JUCE ofrece la clase MidiInputCallback para el manejo de este tipo de mensajes. Una vez establecida la conexión, gracias a la función handleIncomingMidiMessage, el programa se mantiene a la espera de mensajes. Al accionar cualquier control del dispositivo, la función recibe el origen y el mensaje.

Los botones rotatorios son captados como “mensajes de controlador” y se envían a la función midiMove. Los dos botones pulsables se recogen como

Figura 32 - Controlador MIDIMix. En rojo los botones para mover los elementos, en azul los botones de solo y mute y en verde un canal de los ocho disponibles

FUENTE: www.akaipro.com/midimix

B

A

c

Figura 33 - Relación controles del programa con botones del controlador MIDI

http://www.akaipro.com/midimix


47

“mensajes de notas” y se envían a la función midiButton. Cada mensaje tiene asociado el número del botón, con el que se enruta a su acción en el programa.

FUNCIÓN midiButton

La función es llamada cuando se pulsa cualquier botón de mute o solo. Hace la misma labor que la función buttonClicked, pero en este caso debe pedir el estado actual del botón al array correspondiente (muteButtons o soloButtons). Da la orden de cambiar el estado del botón y, en el caso del botón de solo activa los botones mute del resto de elementos y los silencia; y en el caso de los botones de mute silencia el elemento correspondiente.

Se manda repintar la esfera para actualizar los elementos.

FUNCIÓN midiMove

La función es llamada al mover cualquier botón rotatorio. Si el número del botón corresponde con la asociación a los controles del panel, se modifica la posición en el array de sliders correspondiente, para que el valor se actualice automaticamente. Se manda repintar la esfera para actualizar los elementos.

Los rotatorios del controlador se mueven en un rango de 0 a 127. Esto choca con los valores disponibles para la posición de los elementos (de 0 a 360 en el caso de acimut y elevación y de 1.5 a 12.0 en el caso de la distancia). Es necesario convertir la escala del controlador a la del programa. Para ello, se dividen los 361 puntos (105 en el caso de la distancia) disponibles en el programa con los 128 puntos que ofrece el dispositivo MIDI. Se obtiene así el escalón para pasar de una escala a otra y obtener el valor a pasar a los sliders del programa.

Diagrama 9 - Flujo de mensajes MIDI


48

4.8. CREACIÓN DE LA SEÑAL AMBISONICS Y REPRODUCCIÓN

La reproducción de la escena creada es la base de la aplicación. No se debe olvidar que se hace uso de la técnica Ambisonics para crear el espacio sonoro, el cual debe ser reproducido en las tres diferentes configuraciones que se ofrecen: auriculares, ocho altavoces y la esfera de 24 altavoces.

4.8.1. Lectura de archivos

El primer paso es leer los archivos de sonido cargados a la hora de crear la escena. Esto se hace al crear la ventana final, en la clase MainComponent. Para este programa, el manejo de audios se hace mediante buffers, con la clase AudioSampleBuffer, la cual trabaja por medio de muestras o samples. Para leer los archivos wav, se hace uso de la clase AudioFormatReader.

Todos los archivos son almacenados en el buffer fileBuffer, creado como variable global para poder ser leído en cualquier función de la clase. Para poder inicializar fileBuffer (es necesario darle una longitud y un número concreto de canales), se lee el archivo de la ruta del primer elemento y se marca su longitud en el buffer global. Dicha lectura se guarda en el buffer firstBuffer. Tras la lectura, se suman los dos canalesde audio sample a sample para pasarlo a mono y crear así un audio de un único canal. Dicho canal será introducido en el canal 0 del buffer global.

El número de canales de fileBuffer es igual al número de elementos de la escena. Es decir, cada canal contiene el sonido de un elemento. Por lo tanto, todos los audios deben tener la misma longitud y estar codificados de la misma forma, para evitar problemas con la longitud del buffer que los retiene.

Diagrama 10 - Flujo de lectura de archivos de audio


49

Tras trabajar el audio del primer elemento, se repite la operación para todos los elementos de la escena restantes, pasándolos al canal correspondiente del buffer global. Una vez terminado el proceso, se tiene toda la información sonora de la escena en fileBuffer.

4.8.2. Reproducción

La reproducción se hace con la función getNextAudioBlock. Esta contiene bufferToFill, el buffer encargado de la salida de audio. Se debe rellenar con los samples pertinentes para poder reproducir la escena. Su tamaño se calcula automaticamente en preapreToPlay, la cual es llamada cada vez que se cambia de dispositivo de audio, para actualizar el tamaño.

El bloque de samples debe desplazarse en fileBuffer para poder avanzar en la reproducción. Para ello se hace uso de la variable position, cuya labor es guardar la posición del bloque de muestras que se debe coger. Por ello es inicializada a 0 (el principio del buffer) y se le añade el tamaño del bloque cada vez que se pasa por getNextAudioBlock.

Además, la reproducción se puede encontrar en tres estados diferentes (playing, paused y stopped):

1. Playing: la señal Ambisonics es creada y decodificada al sistema requerido.

2. Paused: la función getNextAudioBlock no generará ningún tipo de dato.

3. Stopped: la posición de lectura de fileBuffer es llevada al inicio, es decir, a 0.

El buffer de salida tiene ocho canales creados con la función setAudioChannels. Cuando se implemente la esfera, se iniciarlizará con 24 canales. Cada canal de bufferToFill es redirigido a una salida de audio. Es decir, en el modo auriculares debe tener 2 canales, en el modo de ocho altavoces 8 canales y en el modo esfera 24 canales. Parece un gasto innecesario crear ocho canales (o 24 con la esfera) si solo se van a usar dos, pero no es recomendable modificar el número de canales una vez iniciada la reproducción.

En la función getNextAudioBlock (llamada internamente a la velocidad de salida marcada) se debe crear la señal Ambisonics y pasarla a la configuración de salida indicada por la variable outMode. Los tres estados que dispone outMode son: headphoneConfig (auriculares), labConfig (8 altavoces) y sphereConfig (esfera).


50

4.8.3. Creación de la señal Ambisonics

La señal Ambisonics debe tener 16 canales, al tratarse del tercer orden. Para crearla se necesita la posición, la ganancia y los armónicos esféricos para cada elemento.

La posición y la ganancia de todos los elementos se obtienen al inicio de getNextAudioBlock, y se cargan en en tres arrays: azimuth, elevation, y gain. La ganancia llega como distancia, por lo que se debe convertir a ganacia con una operación matemática: entre la distancia más cercana (1.5) y lejana (12), hay 24 dBs de diferencia (la atenuación de un sonido en campo libre es aproximadamente de 6 dBs cada duplicidad de distancia).

Una vez obtenidas las posiciones, se inicia un bucle para crear la salida de audio de cada elemento. Si el elemento no esta activo se le da un un valor de -100dBs para que no se escuche. Además, acimut y elevación se pasan a coordenadas cartesianas con la clase Conversions, creada en el script Conversions.h perteneciente a los recursos de la plugin suite de IEM [7].

Los armónicos esféricos necesarios se consiguen con la función SHEval3, la cual ha sido adoptada de los recursos de IEM, más concretamente de la clase efficientSHvanilla [7]. A dicha función se le pasan las coordenadas del elemento y devuelve un array con los pesos correspondientes para cada uno de los 16 canales. El array es guardado en la variable global SH. Los armónicos esféricos se normalizan a la semi-normalización de Schmidt con el array n3d2sn3d, situado en el script ambisonicTools.h, también de la plugin suite de IEM [7].

Diagrama 11 - Flujo de reproducción


51

En el caso de la binauralización, se finaliza guardando el bloque correspondiente de muestras de fileBuffer en otro buffer (ambiBuffer) de 16 canales con ganancia igual a la multiplicación entre el armónico correspondiente y la ganancia. En el resto de casos, se debe operar con el vector SH antes de pasar los datos al buffer (ver siguiente apartado).

4.8.4. Decodificación para la configuración de la esfera y los 8 altavoces

Para las configuración de la esfera y de los 8 altavoces, el vector de armónicos SH se debe multiplicar con la matriz de transformación de la configuración para obtener la matriz de decodificación correspondiente y dar salida al audio.

La matriz de transformación contiene la información de la posición de cada altavoz. Para las dos disposiciones disponibles en el programa, se han creado sus matrices de transformación correspondientes con el plugin de IEM AIIRADecoder, que permite introducir cualquier configuración de altavoces y guardar la matriz creada en un json. Se han almacenado en en el archivo decodingMatrix.json, en la carpeta decoding. Al iniciar la ventana final del

Diagrama 12 - Flujo de creación señal Ambisonics


52

programa, en la clase MainComponent, se parsea el archivo y se guardan las dos matrices en el array decodingMatrixArray.

Las matrices de decodificación tienen un número de filas igual al número de armónicos esféricos necesarios para el orden Ambisonics (16 en este caso) y un número de columnas igual al número de altavoces que se usan para su reproducción (8 o 24 en este caso). Su finalidad es convertir la señal Ambisonics de 16 canales a una salida con un número concreto de altavoces.

Como se ha analizado en el apartado Ambisonics, para señales de tercer orden la configuración de altavoces debe ser tridimensional. Sin embargo, la figura de 8 altavoces se presenta en forma bidimensional por lo que, a priori, no se puede decodificar correctamente. El plugin AIIRADecoder soluciona este contratiempo introduciendo altvoces imaginarios y creando una disposición tridimensional “falsa”. Dichas fuentes no aparecen en la matriz de decodificación pero permiten crearla con un tamaño final de 16x8. En contra, la escena pierde su espacialidad sonora vertical.

En la función getNextAudioBlock, se crea la matriz decodingMatrix, a la que se le asignará la matriz de decodificación dependiendo de la configuración que esta en uso. Si se está usando la esfera la matriz se crea con un tamaño de 24x16; en el caso de los 8 altavoces, de 8x16. Para poder hacer los cálculos más facilmente, se convierte el vector de armónicos en una matriz de tamaño 16x1 de nombre harmonicsMatrix.

Multiplicando ambas matrices (decodificación y armónicos), se consigue outMatrix con 8 o 24 valores: la ganancia para cada canal de salida.

4.8.5. Decodificación para auriculares (Binauralización)

Para poder reproducir la escena mediante auriculares es necesario binauralizar la señal Ambisonics. Para ello se hace uso del plugin BinauralDecoder de IEM, del cual se han cogido la función updateBuffers y processBlock, así como partes de código para la creación de variables. BinauralDecoder no utiliza altavoces virtuales para la binauralización, convierte la señal Ambisonics directamente con la técnica ASMD por medio de ffts (transformadas rápidas de Fourier) [3]. Las HRTFs son obtenidas con la cabeza artificial Neumann KU 100 [7].

Diagrama 13 - Flujo de decodificación de la señal Ambisoncis


53

Al crear la ventana, se cargan las respuestas al impulso para 7 órdenes de Ambisonics en el array irs. Aunque la aplicación solo hace uso de la respuesta para el tercer orden, se cree interesante tener disponibles diferente órdenes para futuras versiones. Se crean tambien dos buffers: in y overlapBuffer. El primero es usado para guardar la señal Ambisonics y trabajarla en el domnio frecuencial. El segundo, guarda las muestras producidas por el solapamiento a la hora de hacer las ffts.

Para comenzar el proceso, se llama a la función update, encargada de inicializar las fft y darles el tamaño óptimo. Esta función tambien es llamada al cambiar de dispositivo, desde prepareToPlay, donde se actualiza la longitud del buffer ambiBuffer de 16 canales.

En getNextAudioBlock los 16 canales de ambiBuffer son separados en los de media señal y de señal lateral. Los canales de media señal son diez (canales 0, 2, 3, 6, 7, 8, 12, 13, 14 y 15) y los de señal lateral seis (canales 1, 4, 5, 9, 10 y 11). Para cada uno de ellos, la señal del ambiBuffer es copiada en el buffer in y se guardan los datos frecuenciales en accumSide y accumMid. Finalmente, se ejecutan las ffts BackwardMid y BackwardSide para obtener los arrays de muestras ifftOutputSide y ifftOutputMid, que deben ser direccionados al canal de salida correspondiente.

La señal media obtenida es añadida a ambos canales del buffer de salida bufferToFill, mientras que la lateral se añade al canal 2 y se resta en el canal 1. Además, se añaden las muestras almacenadas en el buffer de solapamiento overlapBuffer.

4.9. PRUEBAS

El espacio sonoro generado por la aplicación ha sido testeado y afinado continuamente durante el proceso de desarrollo. En el caso de la binauralización, no ha hecho falta ninguna clase de dispositivo especial. Los auriculares utilizados para las pruebas de posicionamiento de fuentes sonoras han sido los Sennheiser HD25 [8].

Sin embargo, la configuración con ocho altavoces ha requerido de un espacio preparado y medios técnicos más avanzados. Este espacio se ha creado en el Laboratorio de Acústica de la Universidad Pública de Navarra, en una sala

Diagrama 14 - Flujo de binauralización


54

acústicamente preparada. Los altavoces usados en la conifguración han sido los Neumann KH120 [9]. Para el enrutamiento del audio se han utilizado los ocho primeros canales de la interfaz Focusrite Scarlett 18i20 [10].

Las pruebas se han hecho con un paisaje sonoro y una escena musical, abordando las dos aplicaciones principales que va a tener el programa. Han consistido en mover por el espacio sonoro las diferentes fuentes.

Para la creación del paisaje, se ha optado por recrear un espacio natural. Para ello se han buscado sonidos propios de un paseo por el bosque (pájaros, búho, cigarra, río, cuervo, viento y pisadas) en la base de datos Freesound, una plataforma colaborativa de sonidos gratuita [11].

La escena sonora se ha recreado con el grupo Demode Quartet y su adaptación de la canción Baga Higa Biga de Mikel Laboa. El grupo, que cuenta con cuatro componentes, interpreta acapella versiones originales de temas conocidos [12].

La percepción de la posición ha resultado exitosa tanto en el laboratorio como con los auriculares, pero algo difusa en el desplazamiento vertical, debido a la dificultad de recrear los entornos tridimensionales en configuraciones bidimensionales.

Cuando se termine la construcción de la estructura esférica, se deberán repetir las pruebas para la nueva configuración.

Figura 34 - Dispositivo de prueba para la configuración de ocho altavoces


55

4.10. VISTA A FUTURO

La aplicación está superditada a la esfera de sonido envolvente creada en el proyecto Sonorizart3, la cual se encuentra en fase de construcción. Si bien la programación se ha desarrollado teniendo en cuenta la esfera como opción de salida, se deberá retocar para un correcto funcionamiento.

En otro orden, la situación de excepción generada por la pandemia de la SARS Covid-19 ha reducido el tiempo de desarrollo de la aplicación y del Trabajo Fin de Grado, por lo que el código no ha sido optimizado para una mayor velocidad de lectura. Además, hay varios aspectos y mejoras que se desean introducir en versiones futuras: introducción de archivos sonoros con diferentes longitudes, dar la opción de escuchar escenas ya creadas, añadir más configuraciones de altavoces, poder guardar la escena en un wav, permitir la conexión de diferentes dispositivos MIDI, adaptar la binauralización a diferentes auriculares, etc…

5. CONCLUSIONES

− Se ha introducido el proyecto Sonorizart3 de creación de una esfera con 24 altavoces para reproducir escenas y paisajes sonoros. Este Trabajo Fin de Grado parte de la necesidad de crear una aplicación para reproducir las escenas sonoras tanto en la esfera como en dispositivos de prueba (8 altavoces) y más accesibles (auriculares).

− Se ha trazado la estructura esférica a crear para acomodar los 24 altavoces.

− Se ha analizado la tecnología Ambisonics de grabación, mezcla y reproducción de audio espacial. Dicha tecnología, implementada en su tercer orden, es usada para la creación de las escenas y paisajes sonoros en la aplicación [1].

− Se han investigado los diferentes métodos de binauralización para una señal Ambisonics de tercer orden, creyendo conveniente el uso de la técnica ASDM [3].

− Se ha analizado el estado del arte entorno a la creación y reproducción de señales Ambisonics. Se ha estudiado y adaptado el proceso seguido en diferentes plugins de IEM [7].

− Se ha buscado la herramienta idónea para realizar el trabajo, siendo esta el framework JUCE [4].

− Se ha desarrollado una aplicación funcional, versátil y de uso sencillo, para poder introducir el audio espacial a un amplio abanico de público.

− Durante el proceso se ha aprendido a usar JUCE y programar en lenguaje C++.

− Se han buscado fuentes sonoras en la plataforma Freesound para recrear un paisaje sonoro natural [11].


56

− Se ha probado la espacialidad sonora creada por la aplicación en la configuración de ocho altavoces y auriculares. Se deberán repetir las pruebas cuando esté disponible la esfera.

− Se han analizado posibles mejoras a hacer en la aplicación.

6. BIBLIOGRAFÍA

[1] F. Zotter y M. Frank, Ambisonics, vol. 19, Springer Open, 2019.

[2] Waves, «Waves,» 10 Octubre 2017. [En línea]. Available: www.waves.com/ambisonics-explained-guide-for-sound-engineers.

[3] M. Zaunschirm, M. Frank y F. Zotter, «Binaural Rendering with Measured Room Responses: First-Order Ambisonic Microphone vs. Dummy Head,» Applied Sciences, p. 16, 2020.

[4] JUCE, «JUCE,» 2019. [En línea]. Available: juce.com.

[5] V. Pulkki, «Virtual Sound Source Positioning Using Vector Base,» Journal of the Audio Engineering Society 45(6), pp. 456-466, 1997.

[6] A. Valencia, R. San Martin, A. Ezcurra y M. Arana, «APLICACIÓN EN MATLAB PARA EL DISEÑO Y PRESENTACIÓN DE PAISAJES SONOROS VIRTUALES,» Cádiz, 2018.

[7] IEM, «IEM Plug-in Suite,» 2 Abril 2020. [En línea]. Available: plugins.iem.at/.

[8] Sennheiser, «Sennheiser,» [En línea]. Available: sennheiser.com/hd25. [Último acceso: 3 Junio 2020].

[9] Neumann, «Neumann,» [En línea]. Available: en-de.neumann.com/kh-120-a-g. [Último acceso: 3 Junio 2020].

[10] Focusrite, «Focusrite,» [En línea]. Available: focusrite.com/en/usb-audio-interface/scarlett/scarlett-18i20. [Último acceso: 3 Junio 2020].

[11] MTG, «Freesound,» [En línea]. Available: freesound.org/.

[12] Demode, «Demode Quartet,» [En línea]. Available: demodequartet.com/.

[13] F. Zotter, «Research Gate,» Enero 2014. [En línea]. Available: https://www.researchgate.net/publication/262826740_Spatial_transformations_for_ the_enhancement_of_Ambisonic_recordings.

[14] M. Narbutt, J. Skoglund, A. Allen, M. Chinen, D. Barry y A. Hines, «AMBIQUAL: Towards a Quality Metric for Headphone Rendered Compressed Ambisonic Spatial Audio,» MDPI Open Acces Journals, 3 Mayo 2020.

[15] J. Montero, «Wikipedia,» 2 Enero 2009. [En línea]. Available: commons.wikimedia.org/wiki/File:Coordenadas_esf%C3%A9ricas_figura.svg.

[16] M. o. t. A. L. Aalto University, «Spatial Audio Real-time Applications (SPARTA),» 6 Marzo 2020. [En línea]. Available: research.spa.aalto.fi/projects/sparta_vsts/plugins.html.


57

7. ANEXOS

− ANEXO 1: Relación de scripts, clases, ventanas y funciones.

aplicaciaciÓn para la recreaciÓn de escenas sonoras

Documents