Embed Size (px)
Citation preview
Proyecto de Investigación
Técnicas de DSP para aplicaciones de audio
Andre Zanetti Nascimbeni 10743 AEPF 1006.1
01/10/07
1
1. Índice
2. Resumen ............................................................................................... 3 3. Introducción ......................................................................................... 4
3.1 – Objetivos, revisión crítica y relevancia ......................................... 4 3.2 – Métodos ..................................................................................... 6 3.3 – Herramientas ............................................................................. 7 4. Matlab ................................................................................................... 8 4.1 – Introducción ............................................................................... 8 4.2 – Operaciones ............................................................................... 8
4.3 – Funciones y Toolboxes ................................................................ 9 4.4 - Audio en Matlab ......................................................................... 9 4.5 – Programando en Matlab ............................................................ 10 5. Desarrollo del tema ........................................................................... 11
5.1 - Creación de la librería de sonidos ............................................... 11
5.2 - Encontrando un sonido en una canción ....................................... 11 5.2.1 - Loading files ................................................................. 11 5.2.2 - Extrayendo información ................................................ 12 5.2.3 - Inicializando variables y vectores auxiliares .................... 12 5.2.4 - Comparando vectores ................................................... 12 5.2.5 - Analizando resultados: outliers ...................................... 13
5.2.6 - Calculando la correlación cruzada de dos vectores …….... 15
5.2.7 - Escribiendo el archivo de salida (makeOUT) …….………. 15
2
6. Resultados .......................................................................................... 16
6.1 - Resultados de la primera situación ............................................. 16 6.2 - Resultados de la segunda situación ............................................. 18
7. Conclusión .......................................................................................... 22 7.1 – Encontrando los puntos de repetición ......................................... 22
7.2 – Sonidos Semejantes ................................................................... 22
7.3 - Velocidad de procesamiento ....................................................... 22
7.4 – Substrayendo una señal de una canción ...................................... 22
8. Proyectos futuros ............................................................................... 23 8.1 - Implementación en otras plataformas ......................................... 23 8.2 - Implementación stand alone ....................................................... 23 8.3 - Probar en más situaciones .......................................................... 23
8.4 - Parámetros de conversión .......................................................... 23 8.5 - Implementación estéreo ............................................................. 23 9. Bibliografía ......................................................................................... 24 10. Anotaciones ...................................................................................... 25 11. Agradecimientos .............................................................................. 28
3
2. Resumen
Muchas veces en la producción musical nos encontramos con el problema de tener una mezcla hecha y no poseer los archivos de audio de las pistas separadas. En esos casos, si algún sonido nos disgusta por completo o tiene un nivel en discordancia con los demás instrumentos de la canción, poco tenemos para hacer.
En este trabajo describimos el proceso de creación de un programa escrito en Matlab que, utilizando técnicas de DSP (Digital Signal Processing) ya bien conocidas y estandarizadas por el mercado, analiza archivos de audio que son la mezcla de muchos instrumentos y saca informaciones de los instrumentos que lo componen.
La aplicación descrita busca los puntos del archivo de audio de la canción en que un sonido se repite (sin necesitar, para tanto, una muestra idéntica del sonido separado) y escribe un archivo de audio nuevo con el sonido que vamos a utilizar.
Hemos logrado que la aplicación encuentre el sonido exacto en el archivo mezclado de audio (canción) y también los otros puntos donde el archivo no era exactamente el mismo, pero que era del mismo tipo (por ejemplo, golpes distintos de una caja o de platos).
4
3. Introducción
3.1 – Objetivos, revisión crítica y relevancia El propósito del trabajo es crear una aplicación que detecte en que instantes se
repite un sonido dado (por ejemplo el golpe de un bombo o de una caja, una frase de voz o una frase melódica de algún instrumento) en un archivo de audio. Teniendo como resultado el conjunto de los puntos en que ese sonido ocurre.
Con esa información podemos montar un archivo de audio que sea la repetición del sonido en los puntos encontrados por el programa.
Un ejemplo de aplicación en que esto sería muy útil es cuando ya tenemos una mezcla hecha y alguno de sus componentes nos disgusta (un instrumento, una frase vocal, los golpes de un elemento de la batería, etc.). Una posible solución para cambiar los sonidos que nos molestan, puede ser sumar la señal que deseamos alterar en fase para aumentar su nivel o con la fase invertida para bajar su nivel e incluso borrarla. Tal solución solo es posible si poseemos los archivos de audio de dichos instrumentos separados (aislados del resto de la mezcla). Otra solución es la que proponemos en ese trabajo. Una aplicación capaz de encontrar un tipo de sonido cualquiera en una mezcla, sin que tengamos los archivos de audio separados por pistas y que nos analice en qué puntos ese sonido ocurre, nos posibilita sumarlo a la mezcla como en la primera solución. Algunas aplicaciones estándares de la industria de audio que efectúan cambios de sonidos como los que explicamos anteriormente, trabajan con archivos de audio separados. Ninguna de ellas nos posibilita dicho cambio con la mezcla directamente. Ejemplos de tales aplicaciones son el SoundReplacer, el Drumagog y el ApTrigga2. El SoundReplacer de Digidesign [1] busca en un archivo de audio los transitorios y marca esos puntos para después poner en esos mismos instantes, un sonido a la elección del usuario. Además, analiza el nivel de cada transitorio y los mantiene en los nuevos golpes para mantener el patrón rítmico y la dinámica automáticamente. La versión más actual del SoundReplacer funciona en archivos de mezclas de hasta tres sonidos, pero solo se basa en tres amplitudes distintas de transitorios (tres tresholds), no teniendo en cuenta el tipo de sonidos. Por lo tanto, si los tres sonidos tienen amplitudes de transitorios muy parecidas, no las distinguirás. Digidesign lo comercializa por US$ 395,00.
5
El Drumagog de WaveMachine Labs, Inc. [2] propone algo semejante, reemplaza una pista de un elemento de la batería por un sonido de una galería de samples. Además de los comandos para ajustar la sensibilidad y la resolución de los golpes que deban ser reemplazados, dispone de una ventana para ajustar el treshold visualmente. Se puede alterar el sonido del sample, como por ejemplo, afinarlo cambiando su altura (pitch) y se puede mezclar con el sonido original, haciendo que suenen a la vez.
Es compatible con cualquiera aplicación que lea plug-ins en VST, RTAS o AU y recibe y envía comandos MIDI para poder disparar sonidos de otros aparatos MIDI (de hardware o software).
Puede ser comprado en tres distintas versiones (Basic, Pro y Platinium) además de ofrecer una galería de sonidos de batería. Las versiones cuestan entre US$ 199,00 y US$ 379,00.
Por último, el ApTrigga2 de Apul Soft [3] está disponible para las plataformas Windows y Macintosh en los formatos AU y VST. Tiene las mismas funciones de los dos softwares anteriores, además de añadir una opción para filtrar la señal de entrada para resaltar frecuencias características del sonido a ser reemplazado y así encontrar los transitorios con más fiabilidad. Los fabricantes afirman no tener retraso y, por lo tanto, lo indican para uso en directo. La versión completa puede ser comprada por Internet por EUR 35,00 o US$ 53,84.
6
Los tres programas necesitan las pistas de cada elemento de la batería separadas y no fueron encontrados softwares que propongan cambiar el sonido de algún otro instrumento distinto de una batería. 3.2 – Métodos
El método se constituyó para programar en Matlab algoritmos de comparaciones de vectores y optimizarlos para la aplicación en audio, más específicamente, en la aplicación en cuestión. Dichos algoritmos usan funciones específicas que fueron estudiadas antes de empezar a escribir el código del programa.
Para la optimización del algoritmo, utilizamos distintos archivos de audio que cubrieran un abanico bastante ancho de los tipos de sonido más corrientes en la industria de audio para poner a prueba el código.
Por fin, estudiamos la posibilidad de hacer que ese aplicativo trabaje en tiempo real y que pueda ser abierto como un plug-in por los softwares utilizados en la industria del audio.
Para organizar los pasos de este trabajo, se ha divido en las siguientes actividades: Actividad 1: Búsqueda bibliográfica para el proyecto. Actividad 2: Estudio del Matlab - Estudiamos el programa en cuestión en el que se refiere a las funciones y herramientas que fueron necesarias en el curso del proyecto, como por ejemplo, operaciones con matrices, flujo de programación (for, while, etc…), cómo dibujar gráficos, y cómo escribir programas y aplicaciones. Actividad 3: Creación de una librería de Archivos de Audio - Creamos los archivos de audio que serán usados para poner a prueba el programa. Utilizamos volcados (bounces) de canciones de alumnos del SAE y fragmentos de sonidos aislados extraídos del proyecto multipistas para formar una librería de pruebas por la que el programa fue adaptado. Actividad 4: Programación de Algoritmos
- Escribimos un algoritmo que comparase dos vectores según sus semejanzas. - Escribimos un algoritmo de búsqueda para la mencionada comparación.
- Estudiamos las herramientas de Matlab que calculan la correlación cruzada de dos vectores.
7
- Escribimos un algoritmo que encontrase los outliers de esa evaluación. - Escribimos un algoritmo que encontrase la posición del archivo de audio en que ocurren los outliers. - Escribimos una rutina que escribiese un archivo de audio que será la salida del programa. Contendrá la repetición del sonido en los puntos encontrados por el programa como outliers. Actividad 5: Optimización de los Algoritmos Basándose en la librería de archivos de audio de la Actividad 3, hicimos pruebas del algoritmo y cambios para optimizar su funcionamiento (tanto en calidad como en tiempo). Actividad 6: Análisis de los Resultados Con las pruebas terminadas, analizamos los resultados y pudimos predecir cuáles son los tipos de archivo de audio que el programa debe utilizar en correlación cruzada para encontrar el sonido y en qué tipos la comparación de semejanza es más indicada. Actividad 7: Redacción del Proyecto 3.3 – Herramientas
El programa Matlab de MathWorks fue escogido como herramienta principal del proyecto por su facilidad de programación y su habilidad en dibujar gráficos.
Posee una librería de funciones llamada Signal Processing Toolbox (caja de herramientas para procesamiento de señales) que dispone al usuario los cálculos mas frecuentes en aplicaciones de audio, muy importantes para el trabajo en cuestión.
8
4. Matlab 4.1 – Introducción MATLAB es el nombre abreviado de MATrix LABoratory (laboratorio de matrices) [5]. Matlab es un programa para realizar cálculos numéricos con vectores y matrices. Como caso particular, puede también trabajar con números, tanto reales como complejos, con cadenas de caracteres y con otras estructuras de información más complejas. Una de las capacidades más atractivas es la de realizar una amplia variedad de gráficos en dos y tres dimensiones. Matlab tiene también un lenguaje de programación propio que será introducido más adelante.
Matlab es un programa de cálculo técnico y científico. Para ciertas operaciones es muy rápido, cuando puede ejecutar sus funciones en código nativo con los tamaños más adecuados para aprovechar sus capacidades de vectorización. En otras aplicaciones resulta bastante más lento que el código equivalente desarrollado en C/C++ o Fortran (consecuencias de eso serán vistas más adelante en ese trabajo). En cualquier caso, el lenguaje de programación de Matlab siempre es una magnífica herramienta de alto nivel para desarrollar aplicaciones técnicas, fácil de utilizar y que aumenta significativamente la productividad de los programadores respecto a otros entornos de desarrollo. Matlab dispone de un código básico y de varias librerías especializadas (toolboxes) que serán introducidas más adelante. 4.2 – Operaciones
Matlab puede operar con matrices por medio de operadores y por medio de funciones. Los operadores matriciales de Matlab son los siguientes:
+ Adición o suma – Sustracción o resta * Multiplicación ' Traspuesta ^ Potenciación \ División-izquierda / División-derecha .* Producto elemento a elemento ./ y .\ División elemento a elemento .^ Elevar a una potencia elemento a elemento Estos operadores se aplican también a las variables o valores escalares, aunque
con algunas diferencias. Todos estos operadores son coherentes con las correspondientes operaciones matriciales: no se puede, por ejemplo, sumar matrices que no sean del mismo tamaño. Si los operadores no se usan de modo correcto se obtiene un mensaje de error. Los operadores anteriores se pueden aplicar también de modo mixto, es decir, con un operando escalar y otro matricial. En este caso la operación con el escalar se aplica a cada uno de los elementos de la matriz.
9
Existe también la posibilidad de aplicar elemento a elemento los operadores matriciales (*, ^, \ y /). Para ello basta precederlos por un punto (.). Por ejemplo:
>> [1 2 3 4]^2
??? Error using ==> ^ Matrix must be square. >> [1 2 3 4].^2
ans =
1 4 9 16 >> [1 2 3 4]*[1 -1 1 -1]
??? Error using ==> * Inner matrix dimensions must agree.
>> [1 2 3 4].*[1 -1 1 -1]
ans = 1 -2 3 -4
4.3 – Funciones y Toolboxes
MATLAB tiene un gran número de funciones incorporadas. Algunas son funciones intrínsecas, esto es, funciones incorporadas en el propio código ejecutable del programa. Estas funciones son particularmente rápidas y eficientes.
El concepto de función en MATLAB es semejante al de C y al de otros lenguajes de programación, aunque con algunas diferencias importantes. Al igual que en C, una función tiene nombre, valor de retorno y argumentos. Una función se llama utilizando su nombre en una expresión o utilizándolo como un comando más.
Además de eso, Matlab posee Toolboxes (paquetes que pueden ser adquiridos a parte) que proveen innumerables funciones más específicas. Uno de ellos es el Signal Processing Toolbox con funciones para transformaciones de Fourier de tiempo discreto, herramientas para proyectar filtros digitales y analógicos, cálculos de correlación cruzada y covariancia cruzada que serán bastante utilizados por este proyecto. 4.4 - Audio en Matlab
Habiendo visto cómo trabaja el Matlab con vectores y matrices, es muy simple entender cómo trata los archivos de audio. Si imaginamos el tipo de archivo más sencillo de audio digital, el Microsoft WAVE sound (archivos con la extensión .wav), la información del sonido está codificada en formato PCM (pulse code modulation), o sea, a cada instante un número representa el valor de intensidad sonora (o amplitud) del sonido. Así, un archivo de audio es una larga secuencia de números.
En Matlab, una larga secuencia de números es un vector, o sea, cada archivo de audio es un vector que puede ser manipulado con todas las operaciones matemáticas ya descritas y todas las herramientas de edición de matrices disponibles.
Para abrir el archivo de audio y ponerlo en un vector se ha de utilizar la función waveread (nombre del archivo de audio) que también puede adquirir como información complementaria la frecuencia en la que el archivo fue muestreado y en qué resolución de bits.
El Matlab puede leer, escribir, reproducir y grabar archivos de audio en dos formatos: el ya citado Microsoft WAVE sound y el NeXT sound (archivos con la
10
extensión .au), las funciones para eso son wavread(), wavwrite(), auread(), auwrite(),
wavplay(), wavrecord(),auplay(), aurecord(). Los archivos de audio estéreo también son compatibles con Matlab. En este
caso las informaciones son guardadas en una matriz de dos columnas (una para cada canal) y todas las funciones descritas también son compatibles.
Otras funciones bastante útiles son la sound() o la soundsc() que sirven para enviar un vector a la tarjeta de sonido del ordenador, convirtiendo el vector en sonido. Así podemos escuchar un vector cualquiera, aunque no sea proveniente de un archivo de audio. La información de la frecuencia de muestreo también tiene que ser estipulada (si no, el Matlab reproduce el audio con la frecuencia de muestreo default de 8192 Hz). Leyendo un archivo con una frecuencia de muestreo distinta de la que fue escrita causará que el sonido sea más rápido o más despacio, con la consecuente alteración de pitch (como cuando giramos el plato de un lector de vinilo más rápido o más despacio).
Para esas dos funciones el vector (o matriz) debe tener todos los valores entre -1 y 1, los valores fuera de esa franja cliparán la salida de la tarjeta de sonido.
La segunda función, soundsc(), es la misma que la primera pero, además, maximiza los valores del vector para que se pueda oír el sonido lo más fuerte posible sin que clipe la salida de la tarjeta de sonido. 4.5 – Programando en Matlab
Además de poder insertar operaciones y funciones en la ventana de comandos, el Matlab nos permite agrupar una secuencia de comandos en un archivo de texto como un programa (como un archivo de C, C++ o Pascal), tales archivos se llaman M-Files. Esas rutinas pueden ser llamadas desde la ventana de comandos simplemente escribiendo sus nombres. Eso es muy útil para secuencias de comandos que son utilizadas con frecuencia.
El Matlab también dispone de las sentencias más comunes para flujo de programación tales como las sentencias para escribir bucles for, while, end; comparadores como mayor >, menor <, igual =, mayor o igual >=, menor o igual <=, etc.; y muchas otras expresiones de programación.
También esta disponible un debugger con todas las herramientas necesarias para encontrar fallos en el programa: poner puntos de parada para evaluación de las secuencias de instrucciones paso a paso, step in, step out, etc.
11
5. Desarrollo del tema
5.1 - Creación de la librería de sonidos
El primer paso del proyecto fue crear una librería con archivos de audio para que fueran analizados en el desarrollo del programa. El principal objetivo de ese listado de archivos era tener ejemplos de situaciones reales en que el programa sería utilizado. Para eso, escogemos dos situaciones bastante distintas para poder probar y optimizar el programa.
La primera situación fue la de encontrar una frase de voz en una canción. Por lo cual escogimos una canción que teníamos en el proyecto con todas las pistas separadas en Protools e hicimos dos volcados (bounces), uno de todas las pistas de la canción y otro con la una frase de la pista de la voz . Los dos volcados fueron hechos con las mismas resoluciones de bits (32 bits) y la misma frecuencia de muestreo (48.000Hz). El tipo de archivo escogido fue mono (summed) (porque aún no queríamos hacer pruebas en estéreo) y en Microsoft WAVE audio (.wav) para poder ser leído por Matlab.
Utilizando el transporte del Protools en la opción de visualización de muestras (samples), averiguamos el punto de la canción en que la frase había sido cantada: muestra 35.955.
En la segunda situación queríamos probar encontrar un golpe de caja de la misma canción y averiguar cómo el programa se comportaría con los demás golpes de caja de la canción. Para eso, hicimos dos volcados (bounce) de una parte de la canción donde sonaban tres golpes de caja. Uno solamente de la pista de la caja y otro del segundo golpe respectivamente. Otra vez averiguamos los tiempos (en muestras) donde empezaban los tres golpes (muestra 23.460, muestra 114.540 -el que fue analizado- y muestra 207.500). Los volcados fueron hechos con los mismos parámetros de los anteriores.
De esa manera, esperábamos cubrir un abanico bastante amplio de posibilidades en que el programa debía trabajar.
5.2 - Encontrando un sonido en una canción
Aunque el algoritmo escrito pueda ser utilizado para encontrar la semejanza de cualquier vector en un otro, por la aplicación que tenemos, llamaremos al vector del archivo de audio más grande, vector CANCION y al más pequeño lo llamaremos SONIDO (golpe de caja o frase de voz).
Para un mejor entendimiento, normalmente, se nombran las variables matriciales con letras mayúsculas y los vectores y escalares con letras minúsculas; pero en ese algoritmo, como no tratamos matrices, utilizaremos caracteres mayúsculos para vectores y minúsculos para escalares (salvo en alguna u otra excepción). 5.2.1 - Loading files La primera acción que efectúa el programa es leer los dos archivos de audio y guardarlos en dos vectores que tienen como elementos la amplitud de las formas de onda de las señales de audio.
Como ya describimos en el punto 4.5 - Audio en Matlab, existe la función wavread() que lee los dos archivos de sonido y también retorna las frecuencias de
12
muestreo. En el ejemplo que sigue, los nombres de los archivos de audio para el vector SONIDO y para el vector CANCION son, respectivamente, voz.wav y mono.wav. Sus frecuencias de muestreo serán guardadas en las variables fs y fs2 que, en este caso, son iguales.
[SONIDO, fs] = wavread('voz'); [CANCION, fs2] = wavread('mono');
5.2.2 - Extrayendo información Para la búsqueda de los vectores tenemos que saber sus respectivos tamaños, para eso, usamos la función length() que nos retorna el número de elementos de un vector. El tamaño del vector más pequeño (SONIDO) lo llamaremos L y guardaremos su valor en una variable con el mismo nombre. El otro (CANCION) lo llamaremos max por ser el número máximo de muestras en que tendremos que buscar.
L = length(SONIDO); %137477 max = length(CANCION);
5.2.3 - Inicializando variables y vectores auxiliares
El tercer paso es inicializar las variables y vectores que serán usados por el programa para guardar valores útiles de comparación, o que cambiarán a cada nuevo paso (iteración) del algoritmo de búsqueda. Aunque en Matlab las matrices no tienen que ser inicializadas antes de recibir un valor como en la mayoría de los lenguajes, ese paso sirve para borrar elementos de computaciones anteriores.
El número entero end será hasta dónde el SONIDO tiene que ser comparado, o sea, por toda la extensión de CANCION menos su propio tamaño. El entero n es una variable que guardará en qué paso la comparación está y paso es la resolución de la búsqueda. Un paso de valor 1 hará que la búsqueda compare cada muestra (sample); un paso de 10 hará que la búsqueda analice cada 10 muestras (samples), eso es muy útil para intercambiar resolución de la respuesta por velocidad de procesamiento. El vector M guardará la parte de CANCION que se está comparando en cada iteración, SUMA guardará la suma de los dos vectores comparados y ID es el vector que indica cuánto los dos vectores se parecen en cada punto del archivo de la canción.
end = max - L; %1543680 - L n = 0;
paso = 1; M = []; SUMA = []; ID = [];
5.2.4 - Comparando vectores Para comparar los dos vectores, creamos una rutina (un bucle for) que desplaza el vector SONIDO por todo el vector CANCION y los suma a cada paso; el resultado de esa suma es guardado en SUMA. En cada elemento de ID vamos
13
guardando el resultado de la función sum() que suma todos elementos del vector SUMA y guarda ese valor en un elemento de ID. Como el sonido de una caja está en ambos archivos, cuando esos sonidos coincidan en el tiempo se reforzarán y esa suma tendrá un valor mucho más elevado.
for n = 1:paso:END M = CANCION(n:n+(L-1)); SUMA = SONIDO + M; ID(n) = sum(SUMA);
5.2.5 - Analizando resultados: outliers
La información almacenada en ID debe ser analizada para extraer de ahí los puntos que el programa presentará como respuesta, o sea, los puntos donde ocurre el vector SONIDO en el vector CANCION.
Como estamos comparando paso a paso los dos vectores, en el punto en que los sonidos coinciden en el tiempo, tendremos valores mucho más altos almacenados en ID. Esos elementos serán tratados como outliers, que son valores que discrepan de los demás. El primer paso es calcular los valores absolutos de los elementos para no tener que trabajar con números negativos (y buscar máximos y/o mínimos). La función abs() nos retorna un vector que posee solamente valores positivos calculando el módulo de cada elemento.
absID = abs(ID);
Después se calcula el valor promedio y el desvío de las muestras de absID para analizar cómo están distribuidos los valores almacenados en ID. Esas informaciones son importantes para analizar si el algoritmo funciona adecuadamente. Si la salida del histograma no presenta algunas muestras que salgan fuera del desvío, indica que el algoritmo no tendrá margen para calcular los outliers con precisión.
cuenta_elem = hist(absID); % Informaciones para el histograma N = max(cuenta_elem); % Valor máximo de Cuenta elem mediana = mean(absID); % Promedio sigma3 = std(absID); % Desvio
El vector cuenta_elem y el entero N serán utilizados para hacer un gráfico de histograma de cómo se distribuyen los elementos de ID. Los próximos comandos son necesarios para dibujar el histograma y las líneas del valor promedio y de los desvíos. Es importante recordar que esas líneas de código no estarán incluidas en el programa final puesto que solo sirven para analizar la evolución de la optimización de lo mismo.
hist(absID) % Dibuja histograma hold on plot([mediana mediana],[0 N],'r','LineWidth',2)% Dibuja mediana X = repmat(mediana+(1:2)*sigma3,2,1); Y = repmat([0;N],1,2); plot(X,Y,'g','LineWidth',2) % Dibuja desvíos legend('ID','Mediana','Desvios') hold off
14
El histograma es un tipo de gráfico que cuenta cuántas veces un resultado se repite y presenta los resultados por franjas de valores, miremos el ejemplo abajo:
Este es un histograma típico que el programa presenta para un vector absID (en este caso, para los golpes de la caja). El gráfico dice que, de todos los elementos de absID:
- Casi todos (unos 400.000 elementos) tienen valor entre cero y 2,5. - Algunos pocos (unos 50.000) tienen valor entre 2,5 y 5. - Y lo más importante: muy pocos elementos tienen un valor mayor que 25.
Si sabemos que ocurren aproximadamente 500 golpes de caja en la canción analizada (y no 5.000 o 5) ya tenemos una idea de que los outliers de este vector son los elementos con valores entre 25 y 30.
Por lo tanto, examinando con cuidado el gráfico de histogramas de un vector absID podemos decir qué elementos tienen valores tales que los definan como outliers.
Los próximos comandos sirven para almacenar los outliers en un vector. Para eso, primero tenemos que decidir cuáles son los valores que consideraremos pertenecientes a esa franja. Para eso nos sirve el número entero lim_outliers, que es cuantas veces un elemento (a menos del promedio) tiene que ser más grande que el desvío (sigma3) para ser considerado un outlier. Después de muchas pruebas, definimos lim_outliers como 5.
lim_outliers = 5; outliers = (absID - mediana) > lim_outliers*sigma3; absIDm = absID; % Copia absID en absIDm zeros(1, MAX); outliers = outliers(1:MAX);
En ese paso ya tenemos un vector del mismo tamaño que CANCION, lleno de ceros y con unos solamente en los valores que consideramos outliers.
15
5.2.6 - Calculando la correlación cruzada de dos vectores En algunos casos es más interesante calcular el vector ID (que indica la similitud de los dos vectores analizados) por su correlación cruzada [4]. La correlación cruzada de dos vectores es un cálculo matemático que indica la presencia de una señal en otra. Basada en la operación de convolución, su implementación en Matlab es bastante rápida, por lo que puede ser interesante, en términos de velocidad computacional, como substituto para la rutina de búsqueda de los puntos donde el sonido se repite en la canción.
5.2.7 - Escribiendo el archivo de salida (makeOUT) Desenvolvemos una rutina llamada makeOUT para escribir el archivo de
audio en formato Microsoft WAVE audio (utilizando la función wavwrite() ya descrita) que contiene los samples del SONIDO (golpe de caja o frase de voz) en las posiciones encontradas por el algoritmo. Esperamos, así, tener un archivo de salida que sirva para el usuario poder importar a su proyecto musical (sea en Protools, Cubase, Logic…) y añadir o quitar de la mezcla en cuestión. Como la aplicación básica es para quitar un sonido (o bajar su nivel en relación a los otros instrumentos) el algoritmo ya invierte la fase del sample de SONIDO.
Los pasos para escribir dicho archivo son: teniendo el vector outliers, que tiene ceros en todas las posiciones y “unos” donde el programa encontró outliers, un “loop” while camina por todo vector outliers buscando los “unos”. Cuando los encuentra, escribe (en esa posición pero en el vector OUT) el sample almacenado en SONIDO. Así, el vector OUT se llenara de repeticiones de samples de SONIDO en los puntos que ocurren “unos” en outliers.
En el algoritmo de abajo, n es la posición del vector, OUTinv es el vector que será escrito en el archivo de salida (OUT con la fase invertida), fs es la frecuencia de muestreo con que se escribira ese archivo, 32 es la resolución de bits que usaremos por defecto (puede ser alterada para 8, 16 o 24) y nuevapista es el nombre del archivo de audio (de extensión .wav) que se guardará en la carpeta donde se esté ejecutando la aplicación.
% makeOUT -- Escribiendo el archivo de salida n = 1; OUT = zeros(1,MAX); %inicializa el vector de salida %outliers = + outliers;
while n < END if outliers(n) == 1; %testa si es outlier for m = 1:L OUT(n+m-1) = SONIDO(m); %escribe el SONIDO end n = n+L; %salta el teste para el final de SONIDO else n = n+1; %si no es outlier sigue testando end end OUTinv = - OUT; %invierte la fase del sonido wavwrite(OUTinv,fs,32,'nuevapista')%escribe el archivo de audio
16
6. Resultados
6.1 - Resultados de la primera situación En la primera situación queríamos encontrar una frase de voz en una canción.
Por eso, escogimos una canción que teníamos en el proyecto con todas las pistas separadas en Protools e hicimos dos volcados (bounces) -uno de todas las pistas de la canción- y almacenamos el archivo en el vector CANCIÓN, y otro solo con una frase de la pista de voz y lo almacenamos en el vector SONIDO.
Los vectores CANCION y SONIDO pueden ser vistos en los gráficos a seguir:
Utilizando el transporte del Protools en la opción de visualización de muestras (samples), averiguamos el punto de la canción en que la frase había sido cantada: muestra 35.955, este es el valor que esperamos que el programa encuentre.
Después de ejecutar la rutina de búsqueda, el valor retornado fue 35.955, exactamente el valor esperado, pero un resultado muy negativo fue el tiempo de ejecución del algoritmo: 394.753 segundos como descrito en las estadísticas de análisis del algoritmo (observar “10. Anotaciones”).
El primero intento fue cambiar las líneas más lentas de la rutina, como, por ejemplo, definir el tamaño del vector SUMA antes de empezar a llenarlo de valores. De ese modo, el programa no tiene que alocar memoria en distintos puntos cada vez que el bucle for es procesado. Esa alteración ya produjo un tiempo de procesamiento mucho más bajo: 14,1 segundos (observar “10. Anotaciones”). El resultado fue exactamente igual, ya que no cambiamos el algoritmo, solamente la manera de procesarlo.
Otro análisis fue cambiar el algoritmo de búsqueda por el cálculo de la correlación cruzada entre los dos vectores. El vector ID de semejanza creado, fue:
17
Ya podemos notar que hay un pico muy significativo para ser analizado como
punto de ocurrencia de la frase de voz muy cerca de la muestra 40.000. El valor absoluto de ID, absID, fue:
Y el punto en cuestión es la muestra 40.260, un error de 4.305 muestras o de 10,7%. Pese a que sea un error tan grande, ese resultado (por la correlación cruzada de los vectores) es muy interesante si buscamos intercambiar precisión por velocidad de procesamiento.
El histograma de abajo, nos enseña que tenemos suficiente espacio entre los valores más frecuentes y los que vamos considerar outliers.
18
Y para esos valores el vector OUTLIERS es:
6.2 - Resultados de la segunda situación En la segunda situación queríamos encontrar un golpe de caja de la misma
canción y averiguar cómo el programa se comportaría con los demás golpes de caja de la canción. Para eso, hicimos un volcado (bounce) de una parte de la canción donde sonaban tres golpes de caja y almacenamos en el vector CANCION, después hicimos otro volcado solamente de la pista de la caja y del segundo golpe y almacenamos en el vector SONIDO.
Los vectores CANCION y SONIDO pueden ser vistos a continuación:
Los tiempos (en muestras) donde empezaban los tres golpes eran:
- Primer golpe: muestra 23.460 - Segundo golpe: muestra 114.540 (el que fue almacenado en SONIDO) - Tercer golpe: muestra 207.500
19
Para estos vectores de entrada, el vector ID de semejanza creado y su valor
absoluto absID, fueron:
Se puede notar claramente que en el instante en que ocurre el golpe central, el vector de semejanza asume su valor máximo y que ese punto se encuentra en la muestra 115.861, 1.321 muestras de distancia del valor que procurábamos, o sea, el programa comete un error de 1,14%. A 48.000 muestras por segundo, el error es de 27,5ms.
El resultado más interesante, es el que ocurre en los otros dos golpes de caja. El valor que asume el vector absID es suficientemente más elevado aunque no se trate del mismo sonido de caja (es el mismo instrumento pero fue ejecutado por el músico en tiempos distintos). Los valores de tiempo encontrados (en muestras) son: 23.455 para el primer golpe y 207.535 para el segundo, un error de 5 y 35 muestras respectivamente.
A partir de esos resultados, el algoritmo busca los valores discrepantes para escribir el vector outliers. Tenemos:
20
El próximo paso es escribir el archivo de audio de salida, así, llamamos la rutina makeOUT que nos retorna el archivo de la figura abajo:
El gráfico nos enseña las tres repeticiones de golpes de caja almacenadas en SONIDO en los puntos encontrados por el programa. Como el archivo tiene exactamente el mismo tamaño del archivo de entrada (CANCION), es muy simple importarlo en el proyecto musical.
Abajo podemos ver dónde el programa posiciona la nueva pista (en azul) en relación al archivo original de la caja (en rojo). Podemos notar también que la fase de la nueva caja está invertida.
21
Aunque el alineamiento de los sonidos sea perfecto, el resultado que obtuvimos sumando esa pista a la mezcla fue que el segundo golpe de caja tuvo su nivel reducido notoriamente. En los otros dos golpes, percibimos que la caja pierde un poco de ataque, pero sigue sonando de manera evidente en la mezcla.
22
7. Conclusión 7.1 – Encontrando los puntos de repetición
Concluimos que el programa es muy eficaz en encontrar los puntos donde un
sonido se repite en una canción. Los errores cometidos descritos en Resultados llegaran a un máximo de 1,14%, un valor suficientemente pequeño para no tener relevancia.
7.2 – Sonidos Semejantes
Un punto bastante interesante que debe ser resaltado es el resultado de la segunda situación en que buscábamos un golpe de caja en una canción. Además de haber encontrado con precisión (el sample exacto donde ocurría el golpe), el programa también fue capaz de encontrar los dos otros golpes que a pesar de ser del mismo instrumento, no eran exactamente la misma forma de onda (ya que el músico realizó los tres en distintos tiempos e intensidades).
Ese resultado es muy interesante, ya que indica que el programa no encuentra solamente el sonido justo, sino que es capaz de encontrar sonidos semejantes.
7.3 - Velocidad de procesamiento
En cuanto a la velocidad, las alteraciones hechas en el programa tuvieron una
mejora apreciable, llevando al programa a ejecutarlo en tiempos bastantes aceptables. Aun así, sería muy interesante estudiar la implementación de esa rutina en
otros lenguajes más rápidos para posibles aplicaciones en tiempo real.
7.4 – Substrayendo una señal de una canción
Después de haber encontrado los puntos donde un sonido se repite en una canción, creamos un archivo de audio con una repetición del sonido en esos puntos. Como ese archivo, además, tenía la fase invertida, esperábamos substraer el sonido de la canción solamente con sumar esa nueva pista a la mezcla original.
Ese resultado no fue alcanzado, auque se pudo apreciar una disminución de nivel en la mayoría de las ocurrencias (en los golpes de caja se notó una disminución en el ataque). Una posible causa de eso, es que la forma de onda de las distintas repeticiones del sonido que ocurren en la canción, son suficientemente diferentes como para que sus fases no se cancelen con la de la única muestra que tenemos.
23
8. Proyectos futuros
Algunas ideas que puedan complementar este trabajo en el futuro y proposiciones de estudios correlativos a este trabajo son.
8.1 - Implementación en otras plataformas
Aunque los tiempos de procesamiento hayan sido disminuidos, aun no son aceptables para una aplicación en tiempo real (por ejemplo, como un plug-in de los descritos al principio de este trabajo).
Por lo tanto, sería muy interesante implementar ese algoritmo en otros lenguajes más rápidos como, por ejemplo, C. 8.2 - Implementación stand alone
La actual presentación del programa es como una aplicación escrita para Matlab y, por lo tanto, necesita esa aplicación para funcionar. Para poder disponer de la aplicación de este proyecto, es necesario estudiar una implementación en modo stand alone, o sea, que la aplicación no necesite otra aplicación para funcionar. 8.3 - Probar en más situaciones
El paso más importante en el desarrollo futuro de ese proyecto es ampliar el universo de pruebas en muchas más posibilidades para poder asegurar que el programa retorna resultados correctos en casos distintos, ensanchando el abanico de aplicaciones donde el programa seguramente retorna resultados confiables.
8.4 - Parámetros de conversión
Un estudio que podría ser hecho con esa aplicación, es cambiar los parámetros
de conversión (como frecuencia de muestreo y resolución de bits) de los archivos de sonido, a la hora de hacer los volcados, para probar si esas alteraciones influenciaban el funcionamiento del programa. 8.5 - Implementación estéreo
Otra implementación que podría ser muy interesante en el futuro, es hacer que el programa trabaje también con vectores de dos dimensiones, posibilitando efectuar las mismas tareas con archivos de audio en estéreo. Para esa aplicación, tendría que ser escrita una nueva rutina para buscar un archivo mono en una canción estéreo, para luego substraer el sonido en distintas cantidades de cada uno de los canales (derecho e izquierdo) de la mezcla.
24
9. Bibliografía [1] - Digidesign: www.digidesign.com - Sound replacer de Digidesign: www.digidesign.com/index.cfm?langid=100&itemid=1059 [2] - Drumagog de WaveMachine Labs, Inc. : www.drumagog.com [3] - ApTrigga2 de apulSoft: www.apulsoft.ch/aptrigga/index.php [4] - Correlación cruzada: www.wikipedia.html - Help de Matlab [5] - Tutorial de Matlab: “Aprenda Matlab 7.0 como si estuviera en primero” de Javier García de Jalón, José Ignacio Rodríguez y Jesús Vidal.
25
10. Anotaciones
saefun3voz (1 call, 394.753 sec) Generated 24-Sep-2007 18:03:29 using cpu time. M-script in file C:\Documents and Settings\Andre Nascimbeni\Desktop\Matlab\saefun3voz.m
Lines where the most time was spent
Line Number
Code Calls Total Time % Time
19 ID(n) = sum(SUMA); 249422 362.231 s 91.8%
17 M = CANCION(n:n+(L-
1)); 249422 15.411 s 3.9%
18 SUMA = SONIDO + M; 249422 10.442 s 2.6%
34 end 249422 3.727 s 0.9%
23 if n == 101 249422 2.768 s 0.7%
All other lines
0.173 s 0.0%
Totals 394.753 s 100%
Children (called functions)
Function Name Function Type Calls Total Time % Time
wavread M-function 2 0.126 s 0.0%
Self time (built-ins, overhead, etc.) 394.627 s 100.0%
Totals 394.753 s 100%
M-Lint results
Line number Message
19 'ID' might be growing inside a loop. Consider preallocating for speed.
26
Function listing time calls line
1 % Investiga la similaridad de dos vectores 2 0.13 1 3 [SONIDO, fs] = wavread('cx'); 0.02 1 4 [CANCION, fs2] = wavread('mono'); 1 5 L = length(SONIDO); %137477
1 6 MAX = length(CANCION); 1 7 END = MAX - L; %1543680 - L 8 1 9 n = 0;
1 10 paso = 1; 1 11 M = []; 1 12 SUMA = []; 1 13 ID = []; 14
15 1 16 for n = 1:paso:END 15.41 249422 17 M = CANCION(n:n+(L-1)); 10.44 249422 18 SUMA = SONIDO + M; 362.23 249422 19 ID(n) = sum(SUMA);
20 21 22 2.77 249422 23 if n == 101 0.02 1 24 beep
1 25 if n == 201 26 beep 27 if n == 10001 28 beep 29 end
30 end 1 31 end 32 33 3.73 249422 34 end
35 1 36 absID = abs(ID); 37
27
Profile Summary Generated 24-Sep-2007 18:39:53 using cpu time. Function Name Calls Total
Time Self Time*
Total Time Plot (dark band = self time)
saefun3voz 1 14.089 s 14.043 s wavread 2 0.047 s 0.000 s wavread>read_wavedat 2 0.047 s 0.000 s wavread>read_dat_pcm 2 0.047 s 0.047 s wavread>parseArgs 2 0 s 0.000 s fileparts 2 0 s 0.000 s ispc 2 0 s 0.000 s filesep 2 0 s 0.000 s wavread>open_wav 2 0 s 0.000 s wavread>find_cktype 20 0 s 0.000 s wavread>read_ckinfo 20 0 s 0.000 s wavread>check_rifftype 2 0 s 0.000 s wavread>read_wavefmt 2 0 s 0.000 s wavread>read_fmt_pcm 2 0 s 0.000 s
Self time is the time spent in a function excluding the time spent in its child functions. Self time also includes overhead resulting from the process of profiling.
28
11. Agradecimientos
A Patri, por las correcciones. A Giancarlo Tassara,
por las opiniones y las correcciones.
A SAE A Tato Y a los que llegaran hasta aquí.
