5.

IMPLEMENTACIN DE LOS ALGORITMOS

5.1 INTRODUCCIN

La especificacin MPEG-1 Layer III o MPEG-3 (ISO-11172-3) define la forma en que el

codificador/decodificador debe ser estructurado o interpretado. La salida de un codificador,
elaborada de acuerdo a esta especificacin, se podr reconocer en cualquier decodificador MPEG-3
y viceversa. Sin embargo la especificacin no determina exactamente los pasos de cmo codificar
un flujo sin comprimir en un flujo de bits codificado. Esto significa que varios codificadores
MPEG-3 pueden funcionar de un modo bastante diferente y aun as siguen operando conforme la
norma. Corresponde al desarrollador la manera de ejecutar determinadas partes del codificador. Por
ejemplo, no es especfica la forma de tratar con las frecuencias de ms de 16 kHz. Dado que es muy
difcil detectar seales de audio en esa gama de frecuencia, un desarrollador puede optar por
desechar estas frecuencias, con lo cul dejar los bits disponibles para ms seales audibles.
Dos aspectos importantes en el desarrollo de un codificador son la velocidad y la calidad.
Lamentablemente, las implementaciones aportadas por la norma no siempre se aplican a los
algoritmos ms eficientes. Esto da lugar a enormes diferencias en la velocidad de funcionamiento
de varios codificadores. La calidad de la seal codificada tambin puede variar en funcin del
codificador.
En cuanto a la decodificacin, todas las transformaciones necesarias para producir las muestras
PCM estn definidas. Sin embargo, faltan detalles para algunas partes y el nfasis recae sobre la
interpretacin de la codificacin de bits, sin usar la mayora de algoritmos eficientes, en algunos
casos.
Esta libertad de la aplicacin dada por el estndar MPEG-3 debe ser cuidadosamente considerada
con el fin de encontrar una buena aplicacin. Tambin es importante optimizar siempre la
codificacin y decodificacin de los procedimientos, ya que no estn optimizados en la definicin
estndar.
Para la realizacin de los algoritmos del codificador se ha recurrido a distintas fuentes de
informacin, la principal la especificacin ISO 11172-3, a donde hemos recurrido para realizar la
implementacin propia en Matlab de las siguientes partes del codificador:
Banco de Filtros
FFT (Fast Fourier Transform)
Transformada discreta del coseno o MDCT
Las restantes partes como la implementacin en Matlab del Cuantificador No-uniforme,
Codificacin Huffman, Codificacin de la Informacin Secundaria y el Formato del Flujo de Bits,
se comprob que ya haban sido implementas por Alexander Vargas y Alejandro Duque [n], de
dnde realizando una exhaustiva comprobacin de dichos algoritmos, encontramos una serie de
errores provocados por una incorrecta implementacin sobre todo en el algotimo de Codificacin
Huffman; se modificaron y adecuaron dichos errores a la especificacin ISO 11172-3 para el
correcto funcionamiento del codificador.
Para la implementacin del algoritmo Modelo Psicoacstico, debido a que la especificacin
ISO 11172-3, deja esta parte un poco ms de libre eleccin entre dos tipos de modelos, tales como
el Modelo Psicoacstico I y el Modelo Psicoacstico II, despus de examinar ambos modelos, se
tom la decisin de utilizar el Modelo Psicoacstico I adaptndolo al MPEG-1 layer III; ya que en
la especificacin de dicho modelo recomienda dicha adaptacin si se quiere utilizar para MPEG-1
layer III, en el apartado 5.X XXXX se ver de forma ms detallada estas adaptaciones, se debe
sealar que como base de estudio al modelo se tubo muy en cuenta la aportacin del documento [].

5.2 XXXXXX
En esta apartado se mostrar una descripcin detallada de la herramienta de aprendizaje nombre
del tutorial. Antes comenzar, para conocer la aplicacin, en la Figura 5.1 se muestran las distintas
partes de nombre del tutorial.

Figura 5.1

La primera opcin Codificador MPEG-3, describe todo el procesamiento sobre la seal de

audio que se lleva a cabo cuando es codificada al formato MPEG-3.
La segunda opcin Modelo Psicoacstico, describe paso a paso la aplicacin del modelo
psicoacstico segn el estndar ISO 111172-3.
Y la tercera opcin Resultados, describe el resultado obtenido tras la codificacin de las seal
de audio, pudindose comparar con la seal original.
OPCIN 1- CODIFICADOR MPEG-3
Si el usuario elige la opcin Codificador MPEG-3, en la Figura 5.2 se muestra la ventana
grfica que explica las distintas partes del codificador que se han implementado en este tutorial(o
nombre del tutorial).
 Figura 5.2
El funcionamiento de esta opcin del tutorial se muestra en el diagrama de la Figura 5.3.

Figura 5.3(tengo k repetir el diagrama)

En primer lugar, para empezar a utilizar el codificador se debe cargar el archivo de audio. Segn
las especificaciones del programa, este archivo wav debe ser monofnico y con una frecuencia de
muestreo igual a 44100 Hz. Pulsando Archivo->Abrir y aparecern un listado con algunos
archivos wav con dichas caractersticas. Al escoger un archivo, aparecer la siguiente ventana:

Segn se estudi en el capitulo 2, inicialmente el codificador estructura la seal de audio de

entrada en paquetes de muestras, cada uno de ellos con un tamao de 1152 muestras, denominadas
tramas, en este apartado del tutorial, se tiene la opcin de visualizar el procesado de la seal por los
distintos bloques del codificador durante las primeras 5 tramas.
 BANCO DE FILTROS
Si el usuario presiona el botn Banco de Filtros aparecer la ventana grfica mostrada en la
Figura 5.4. Donde se observa una breve explicacin del funcionamiento del banco de filtros segn
especificacin ISO 111172-3, un diagrama de bloques y un diagrama de flujo del mismo.

Figura 5.4
El botn Coeficientes representa grficamente los coeficientes de la ventana de anlisis del
prototipo del filtro paso bajo proporcionados por el estndar ISO [], se presentan en la figura 5.5.

Figura 5.5

El botn Resp en Frec representa grficamente la respuesta en frecuencia de la banda del filtro
seleccionado, esta eleccin de la banda la realiza el usuario y pertenece al intervalo de valores
[1..32], un ejemplo queda reflejado en la Figura 5.5.
 Figura 5.5
En el ejemplo, se muestra la banda de frecuencias recogidas para la primera subbanda. Como puede
verse, no recoge las frecuencias cercanas a la componente continua. Eso no es un problema en la
prctica, es ms, el estndar ISO para MPEG-3, aconseja la inclusin de un filtro paso alto con una
frecuencia de corte de 2 a 10 Hz. De esta forma, se evita una innecesaria alta tasa binaria para la
subbanda inferior, y aumenta la calidad de audio en general.
La frecuencia de muestreo de la seal PCM es de 44.1 kHz, por lo tanto cada subbanda tendr
aproximadamente 44100/32 = 1378 Hz de ancho, y una frecuencia central, fc = (fm/64)*n, para
n=1..32. Estas subbandas estn igualmente espaciadas en frecuencia, y no reflejan exactamente las
bandas crticas del odo.
La implementacin en Matlab de este bloque es la siguiente:

%valor pertenece al
intervalo[1..32] ser introducido
por el usuario.
%H son los coeficientes del filtro
prototipo proporcionados por el
estndar.

V=filtrosub(valor,H);
fvtool(V,'Fs',44100);

function V=filtrosub(k,H)
for n=1:512

V(n)=H(n)*cos(((2*k + 1)*(n-16)*pi)/64);

end

end

H es un vector de coeficientes de 512 elementos que corresponde con la respuesta prototipo del
filtro paso bajo, proporcionados por el estndar que quedan recogidos en el Anexo 1. fvtool es una
herramienta proporcionada por la librera de Matlab, que sirve para representa la magnitud de la
respuesta del filtro a partir de los coeficientes de la funcin de transferencia del mismo.
Para justificar la implementacin de este bloque del codificador se recuerda que en el captulo 2
la salida del filtro que se concluy fue:

63 7
S t [i ]= M [i][k ]C [k 64j]x [k 64j] Eq 5.1
k=0 j=0

Donde:
i es el ndice de la subbanda comprendido desde 0 a 31.
S t [i ] es la muestra de salida para la subbanda i en el tiempo t, donde t es un
mltiplo de 32 intervalos de la muestra de audio.
C[n] es uno de los 512 coeficientes de la ventana de anlisis defino por el estndar.
x[n] es una muestra de audio de entrada perteneciente al bffer de 512 muestras.
2i1k 16 son los coeficientes de la matriz de anlisis.
M [i][ k ]=cos [ ]
64

Es posible modificar la ecuacin 5.1. utilizando la tpica ecuacin de convolucin:

511
S t [i]= x [tn]H i [n]
n=0

Donde:
x[t] es una muestra de audio en un tiempo t.
2i1k 16
H i [n]=h [n]cos[ ]
64
con h[n]= -C[n], si la parte entera de (n/64) es impar,
o h[n] = C[n] en el
caso contrario, para n = 0 hasta 511.

De esta forma cada subbanda del banco de filtros tiene su propio filtro pasa banda
correspondiente a la respuesta al impulso Hi[n]. Esta ecuacin es la que se ha utilizado en el
algoritmo filtrosub(..) para mostrar la magnitud de la respuesta en frecuencia en cada banda.
 TRANSFORMADA DISCRETA DEL COSENO-MDCT
Este bloque presenta la ventana grfica mostrada en la Figura 5.6. Consta de una breve
explicacin sobre la MDCT, un diagrama de bloques que muestra el comportamiento del mismo y
una figura explicativa con los tipos de ventana posibles: normal, short, start y stop.

Figura 5.6

Como puede observarse en la Figura 5.6, se tiene la opcin de visualizar la Transformada

discreta del coseno para cada grnulo, as como para ambos. Si se oprime el botn MDCT,
aparece en pantalla la transformada correspondiente al grnulo elegido por el usuario, como se
muestra en la Figura 5.7.

Figura 5.7
 En este bloque, se subdivide cada una de las 32 bandas (salidas del banco de filtros) mediante
una transformacin DCT Modificada, con el 50% de solapamiento, sobre 18 puntos (lneas de
frecuencia) de la seal que se corresponde a lo que denominamos en el captulo 2 como grnulo.
Esta subdivisin consigue una mejor resolucin en frecuencia con respecto a las bandas crticas.
Con una fm=44.1 kHz de la seal de audio PCM, el nmero mximo de componentes en
frecuencia es: 32 x 18 = 576, obteniendo una resolucin en frecuencia (ancho de banda) de:
fm/ 2
= 38,28 Hz en cada banda.
576
Como se aprecia en la Figura 5.7, se muestran los coeficientes obtenidos tras aplicar la MDCT y
reducir el aliasing introducido por el banco de filtros en el bloque anterior y por el solapamiento del
50% introducido en la MDCT.
La implementacin en Matlab del bloque MDCT es la correspondiente:

%S es una matriz de 32 filas x 36 columnas que contiene las muestras de

%audio de una trama tras ser filtradas con el banco de filtros.
%U almacena los ltimos 576 valores de la trama anterior (matriz S).
%gr se corresponde con el grnulo
%sub es la subbanda del filtro a procesar.

global S;
MDCT = [];
U = S(19:36,:);
for gr=1:2
for sub = 1:32

MDCT = [MDCT; Transf(S,U,sub,gr)];

end

% Reduce el aliasing introducido por el 50% de solapamiento de la

MDCT.
XR = Aliasing(MDCT(1+576*(gr-1):576*gr));

end

function MDCT = Transf(S,U,sub,gr)

%Calcula la transformada discreta del coseno modificada.
%
% Retorna los 18 valores (vector MDCT) correspondientes al resultado de
aplicar la transformada discreta del coseno modificada, con 50% de
solapamiento, sobre 36 muestras subbanda consecutivas en el tiempo.
%
% S es la matriz de 1152 muestras subbanda obtenidas con el filtro subbanda.
% La matriz U proporciona las ltimas 576 muestras subbanda de la matriz
anterior, sub es la subbanda, gr es el grnulo actual.

if gr == 1

xp = [U(1:18,sub); S(1:18,sub)];

else
 xp = S(1:36,sub);
end

% Calcula el vector z de 36 valores para el tipo de bloque NORMAL.

z = xp' .* sin((pi/36)*(0.5:35.5));

% Calcula el vector MDCT de 18 valores para bloques largos.

MDCT = zeros(18,1);
fMDCT = pi/72*(19:2:89);
for i = 1:18,
MDCT(i) = sum(z.*cos((2*i+1)*fMDCT));
end

En cada subbanda, los 18 valores de salida del grnulo anterior (almacenados en U) y los 18
valores de salida del grnulo actual se ensamblan en un bloque de 36 muestras (vector xp). En caso
de que el grnulo sea el segundo, para cada subbanda, la matriz S es procesada directamente.
En la implementacin solo se ha tenido en cuenta el tipo de bloque normal para el
enventanado de la seal.
La reduccin de aliasing se procesa de la siguiente forma:
function MDCTSin = Aliasing(MDCT)
%ALIASING Reduce el aliasing introducido por la MDCT.
%

% Retorna en el vector MDCTSin de 576 valores el resultado de la reduccindel

% aliasing introducido por el 50% de solapamiento usado al aplicar la MDCT o
% transformada discreta del coseno modificada.
%
% El vector MDCT contiene los 576 valores de la transformacin obtenida a
% travs de Transf.
%

MDCTSin = [];

% Constantes para el clculo mariposa, proporcionadas por el estndar

% ISO/IEC 11172-3 (vectores c, cs y ca).
% c = [-0.6; -0.535; -0.33; -0.185; -0.095; -0.041; -0.0142; -0.0037];
% cs = 1 ./ sqrt(1+c .^ 2);
% ca = c ./ sqrt(1+c .^ 2);
cs = [0.85749292571254; 0.88174199731771; 0.94962864910273; 0.98331459249179;
0.99551781606759; 0.99916055817815; 0.99989919524445; 0.99999315507028];
ca = [-0.51449575542753; -0.47173196856497; -0.31337745420390;
-0.18191319961098;
-0.09457419252642; -0.04096558288530; -0.01419856857247; -0.00369997467376];

MDCTcs = zeros(8,2);
MDCTca = zeros(8,2);

for i = 11:18:551

% Las lneas de frecuencia se multiplican por cs y ca.

MDCTcs = [[MDCT(i+7:-1:i) .* cs] [MDCT(i+8:i+15) .* cs]];
MDCTca = [[MDCT(i+7:-1:i) .* ca] [MDCT(i+8:i+15) .* ca]];

% El concepto mariposa involucra sumar y restar las lneas de frecuencia en

% pares, entregando dos nuevas lneas de frecuencia por cada par. En
%total, se reemplazan 16 lneas de frecuencia (vector MDCTBparcial).
MDCTSinparcial = [MDCTcs(8:-1:1,1)+MDCTca(8:-1:1,2); MDCTcs(:,2)-MDCTca(:,1)];
% Concatenacin del resultado anterior con los dos valores de MDCT a los que
% no se les aplica la reduccin del aliasing.
MDCTSin = [MDCTSin; MDCTSinparcial; MDCT(i+16:i+17)];

end

% Los primeros 10 y los ltimos 8 valores de MDCT (que no son incluidos en el

% clculo mariposa) se conservan para MDCTSin.
MDCTSin = [MDCT(1:10); MDCTSin; MDCT(569:576)];

Para entender mejor estos dos bloques del codificador la Figura 5.8 muestra un esquema resumen
de lo visto hasta ahora.

Figura 5.8: Procesamiento de la seal para Banco de Filtros/MDCT .

 FFT (FAST FOURIER TRANSFORM)
La FFT se realiza sobre las muestras de audio que provienen del archivo wav, en concreto se va
transformando al dominio de la frecuencia paquetes de 1152 muestras en el tiempo, que
corresponde con una trama de audio MPEG-3.
Si el usuario oprime el botn FFT 1024 PUNTOS, se realiza la transformada de fourier rpida,
mostrada en la Figura 5.9.

Figura 5.9

El espectro slo tiene 512 valores debido a la simetra de la FFT. La cantidad de puntos sobre los
que se realiza la transformada son 1024 segn el estndar ISO. Con el fin de ofrecer una cobertura
completa al realizar la FFT, se escogen las 1024 muestras centrales de las 1152.

La implementacin en Matlab es la siguiente:

%La variable de entrada vector equivale a 1152 muestras de audio PCM

function F = Analisis_fft(vector)

s=vector(65:1088);

% Calcula la ventana de Hanning de 1024 puntos (vector h).

h = sqrt(8/3) * hanning(1024);

% Obtiene la densidad espectral de potencia a travs de la FFT.

% F se reduce a la mitad de componentes, por la simetra de la FFT.

F = (abs(fft(s .* h))/1024);
F = F(1:512);

end
 MODELO PSICOACSTICO
Este bloque del Codificador MPEG-3, presenta la ventana grfica mostrada en la Figura 5.10. En
ella se observa una breve introduccin al Modelo psicoacstico y un esquema que resume el
fenmeno del enmascarmiento, concepto bsico y primordial debe ser conocido para entender la
aplicacin de este modelo.

Figura 5.10

Este apartado se estudia con ms detalle en MENU->MODELO PSICOACSTICO.

CUANTIFICACIN NO UNIFORME/CODIFICACIN HUFFMAN

En el bloque de CUANTIFICACIN se examinan tanto las muestras de salida del bloque
MDCT como el SMR (SIGNAL-TO-MASK RATIO) proporcionado por el modelo psicoacstico, y
ajusta la asignacin de bits o ruido. La codificacin Huffman, basada en 32 tablas de cdigo se
utilizan para una eficiente representacin de los valores cuantificados. El codificador delimita los
coeficientes MDCT cuantificados en tres regiones diferentes: Big Values, Count1, Rzero.
Esto permite al codificador codificar cada regin con un conjunto diferente de tablas de Huffman.
En la Figura 5.11 se observa un ejemplo de muestras cuantificadas para un grnulo.

Figura 5.11
 La muestras frecuenciales son cuantificadas y codificadas dentro de 2 lazos de iteracin que
tienen lugar en el codificador. Los lazos de iteracin cuantifican las muestras de salida del bloque
MDCT de acuerdo a varias demandas. Como ya se enunci en el captulo 2, existen 2 lazos de
iteracin: el lazo interno y el lazo externo.
En el lazo interno se cuantifica el vector de muestras de entrada que provienen de la MDCT y se
incrementa el tamao del paso del cuantificador hasta que el vector de muestras de salida pueda ser
codificado con el nmero de bits disponible.
En el lazo externo se chequea la distorsin de cada SCF band (bandas de factor de escala) y, si la
mxima distorsin permisible se excede, se amplifica los la SCF band y se invoca nuevamente el
lazo interno.
Las bandas de factor de escala (scalefactor band) se utilizan para moldear el ruido de
cuantificacin de acuerdo al umbral de enmascaramiento global. Existen tablas que indican el
nmero de particiones que van a cada una de esas bandas de factor de escala. El sistema comienza
con un factor por defecto de 1.0 para cada banda. Si el ruido de cuantificacin en una determinada
banda excede el umbral de enmascaramiento global (ruido permitido) obtenido del modelo
psicoacstico, el factor de escala para esta banda se ajusta para reducir el ruido de cuantificacin.
Luego el ciclo externo se encarga de verificar si el factor de escala para cada subbanda tiene ms
distorsin que la permitida (ruido en la seal codificada), comparando cada banda del factor de
escala (scalefactor band) con los datos previamente calculados en el anlisis psicoacstico.

Ciclo interno - control de la tasa de bit

En el lazo de iteracin interno se realiza la cuantificacin de las lneas del dominio de la
frecuencia y se prepara el formateo. As como la seleccin de tablas para la codificacin Huffman,
subdivisin del rango de big_values en regiones y la seleccin del escaln de cuantificacin.

Parmetros de entrada:
vector XR(1..576) es el vector de muestras subbanda obtenido tras el bloque MDCT
system_const es la constante del sistema
SFBT es la matriz que proporciona las bandas del factor de escala
Parmetros de salida:
IX es el vector de valores espectrales cuantificados (sin tener en cuenta el signo de XR)
IS es el vector de valores espectrales cuantificados (teniendo en cuenta el signo de XR)
SHT es la matriz que contiene las 3 tablas de Huffman seleccionadas para codificar las 3
subregiones de la regin big_values
overall_bitsum representa la cantidad de bits que se usan para codificar los valores
cuantificados
count1table_select indica la tabla de Huffman escogida para codificar los cudruplos de
de valores pertenecientes a la regin count1
big_values es la cantidad de valores espectrales, contados por pares, ubicados en las bajas
frecuencias
region0_count es la cantidad de bandas del factor de escala (disminuidas en 1) incluidas
 en region0
region1_count es la cantidad de bandas del factor de escala (disminuidas en 1) incluidas
en region1
table_select es el vector que incluye el nmero de las tablas de Huffman usadas para
codificar region0, region1 y region2
qquant y quantanf son los valores usados para el intervalo de cuantificacin
rlb es el vector que indica cuntos bits deben usarse para codificar cada uno de los valores
adicionales en cada una de las 3 subregiones en que se divide big_values(el valor adicional
es necesario si el valor mximo de la subregin es mayor que 15)
count1 es la cantidad de cudruplos incluidos en la regin count1 (regin intermedia del
vector IX)
fe es el vector que indica el principio de cada una de las 3 subregiones en que se divide
big_values
ff es el vector que indica el final de cada una de las 3 subregiones en que se divide
big_values

function [IX,IS,SHT,overall_bitsum,count1table_select,big_values,region0_count,
region1_count,table_select,qquant,quantanf,rlb,count1,fe,ff] = ...
Ciclo_interno(XR,system_const,SFBT)
% Inicializacin de variables.
sfm = exp(sum(log(XR.^2))/576)/(sum(XR.^2)/576); % Calcula la planura
espectral.
quantanf = system_const*log(sfm); % Seleccin del intervalo de cuantizacin.
qquant = 0; % Seleccin del intervalo de cuantizacin.

% Cuantiza los valores del vector XR. En IX se almacenan los valores

% absolutos y en IS se almacenan los valores signados.
IX = round((abs(XR)/(2^((qquant+quantanf)/4))) .^ 0.75 - 0.0946);
IS = sign(XR).*IX;

% Cuando todos los valores del vector IX son cero, se termina el Ciclo Interno.
if IX == 0
count1table_select = 0;
big_values = 0;
region0_count = 0;
region1_count = 0;
table_select = zeros(1,3);
overall_bitsum = 0;
SHT = zeros(256,6);
rlb = zeros(1,3);
count1 = 0;
fe = ones(1,3);
ff = ones(1,3);
return
else
% Limita a (8191 + 15) el valor mximo de los componentes del vector IX.
while max(IX) > 8206,
qquant = qquant+1;
IX = round((abs(XR)/(2^((qquant+quantanf)/4))) .^ 0.75 - 0.0946);
IS = sign(XR).*IX;
end

% Calcula el nmero de pares de ceros (rzero) en el extremo superior

% del vector IX.
 rzero = 0;
for i = 576:-1:1,
if IX(i) == 0
rzero = rzero + 0.5;
else
break
end
end
rzero = fix(rzero);

% Calcula el nmero de cudruplos de valores (count1) en el vector IX cuyo

valor
% absoluto no es mayor que uno, y que siguen luego de los valores rzero (en la
% parte intermedia del vector IX).
count1 = 0;
for i = 576-rzero*2:-1:1,
if IX(i) == 0 | IX(i) == 1
count1 = count1+0.25;
else
break
end
end
count1 = fix(count1);

% Calcula el nmero de pares de valores (big_values) en el extremo inferior

% del vector IX.
big_values = (576-rzero*2-count1*4)/2;

% Almacena en bitsum_count1 el nmero de bits necesario para codificar los

% valores count1. Adems, determina la tabla de Huffman ms apropiada para
% dicha codificacin (count1table_select).
count1table_0 = [1 4 4 5 4 6 5 6 4 5 5 6 5 6 6 6];
% Calcula los bits que se consumen con la tabla B.
bitsum_table1 = count1*4;
% Calcula los bits que se consumen con la tabla A.
bitsum_table0 = 0;
for k = big_values*2+1:4:big_values*2+count1*4,
bitsum_table0 = bitsum_table0+count1table_0(8*IX(k)+
+4*IX(k+1)+2*IX(k+2)+IX(k+3)+1);
end
% Calcula cuntos bits de signo se usan para la regin count1.
count1_signbits = length(find(IX(big_values*2+1:576-rzero*2)));
% Calcula la cantidad total de bits que consume la regin count1,
% usando la tabla de Huffman que usa menos bits para codificar los
% cudruplos count1.
bitsum_count1 = min(bitsum_table0,bitsum_table1) + count1_signbits;
if bitsum_table0 < bitsum_table1
% Escoge la tabla A, proporcionada por el estndar ISO 11172-3.
count1table_select = 0;
else
% Escoge la tabla B, proporcionada por el estndar ISO 11172-3.
count1table_select = 1;
end

% Divide la regin de los valores big_values en 3 subregiones, cuyos lmites

% deben coincidir con los lmites de las bandas del factor de escala incluidas
% en el tamao de dicha regin. Los valores de region0_count y region1_count
% obtenidos aqu, no estn regidos por los requerimientos del estndar ISO
%11172-3.
if big_values == 0
bvscfb = 0;
else
for i = SFBT,
 if big_values*2 <= i(4)
break
end
end
bvscfb = i(1);
end
region0_count = fix(bvscfb/2);
region2_count = fix(bvscfb/4);
region1_count = bvscfb - region0_count - region2_count;

% Encuentra el mximo valor cuantificado de cada subregin (max_region), el

% cual sirve para calcular linbits (vector rlb). Estos dos valores permiten
% seleccionar las tablas de Huffman apropiadas (matrices HCTN y HCT) para
% codificar cada una de las subregiones de big_values. En este paso, se puede
% dar la posibilidad de hasta tres (3) tablas de Huffman por subregin, para un
% caso mximo de nueve (9) tablas seleccionadas para big_values.
Posteriormente,
% se realiza la seleccin de la tabla ms apropiada para cada subregin.
% Adicionalmente, se inicializa apropiadamente la variable bitsum_table, de
% acuerdo con la cantidad de subregiones en que se divide big_values.
rlb = zeros(1,3);
HCTN = zeros(3);
HCT = zeros(256,18);
if bvscfb > 3
% Caso 1. La regin big_values se ha dividido en tres (3) subregiones.
% Mximo nueve (9), mnimo tres (3) tablas para big_values.
fe = [1,SFBT(4,region0_count)+1,SFBT(4,region0_count+region1_count)+1];
ff =
[SFBT(4,region0_count),SFBT(4,region0_count+region1_count),big_values*2];
max_region0 = max(IX(1:ff(1)));
max_region1 = max(IX(fe(2):ff(2)));
max_region2 = max(IX(fe(3):ff(3)));
if max_region0 > 15
rlb(1) = ceil(log2(max_region0 - 14)); % Clculo de linbits, region0.
end
if max_region1 > 15
rlb(2) = ceil(log2(max_region1 - 14)); % Clculo de linbits, region1.
end
if max_region2 > 15
rlb(3) = ceil(log2(max_region2 - 14)); % Clculo de linbits, region2.
end
% Seleccin de la(s) tabla(s) de Huffman por subregin.
[HCTN(1,:),HCT(:,1:6)] = Huffman(rlb(1),max_region0);
[HCTN(2,:),HCT(:,7:12)] = Huffman(rlb(2),max_region1);
[HCTN(3,:),HCT(:,13:18)] = Huffman(rlb(3),max_region2);
bitsum_table = ones(3)*inf;
elseif bvscfb == 1 | bvscfb == 2
% Caso 2. La regin big_values se ha dividido en una (1) subregin.
% Mximo tres (3), mnimo una (1) tabla para big_values.
fe = [1, 1, 1];
ff = [1, big_values*2, 1];
max_region1 = max(IX(1:ff(2)));
if max_region1 > 15
rlb(2) = ceil(log2(max_region1 - 14)); % Clculo de linbits, region1.
end
% Seleccin de la(s) tabla(s) de Huffman por subregin.
[HCTN(2,:),HCT(:,7:12)] = Huffman(rlb(2),max_region1);
bitsum_table = [zeros(1,3); ones(1,3)*inf; zeros(1,3)];
elseif bvscfb == 3
% Caso 3. La regin big_values se ha dividido en dos (2) subregiones.
% Mximo seis (6), mnimo dos (2) tablas para big_values.
fe = [1, 5, 1];
ff = [4, big_values*2, 1];
 max_region0 = max(IX(1:4));
max_region1 = max(IX(5:ff(2)));
if max_region0 > 15
rlb(1) = ceil(log2(max_region0 - 14)); % Clculo de linbits, region0.
end
if max_region1 > 15
rlb(2) = ceil(log2(max_region1 - 14)); % Clculo de linbits, region1.
end
% Seleccion de la(s) tabla(s) de Huffman por subregin.
[HCTN(1,:),HCT(:,1:6)] = Huffman(rlb(1),max_region0);
[HCTN(2,:),HCT(:,7:12)] = Huffman(rlb(2),max_region1);
bitsum_table = [ones(2,3)*inf; zeros(1,3)];
elseif bvscfb == 0
% Caso 4. La regin big_values no existe, y por lo tanto, no hay
%subdivisin.
fe = [1, 1, 1];
ff = [1, 1, 1];
bitsum_table = zeros(3);
end

% Ajusta los valores de region0_count y region1_count, de acuerdo con los

% requerimientos del estndar ISO 11172-3.
if region0_count ~= 0
region0_count = region0_count - 1;
end
if region1_count ~= 0
region1_count = region1_count - 1;
end

% A partir de las tablas de Huffman seleccionadas anteriormente (mnimo 1,

% mximo 3 tablas para cada subregin), escoge aquella que usa menos bits
% en la codificacin (table_select y la matriz SHT), y calcula los bits
% necesarios para codificar los valores en cada subregin. Por ltimo,
% calcula overall_bitsum, que es la cantidad total de bits que se usan
% para codificar los valores cuantificados. Primero, se cargan los valores
% mximos de las tablas de Huffman.
maxth = [1 2 3 3 0 4 4 6 6 6 8 8 8 ones(1,19)*16];
% Despus, se realiza el conteo de bits con todas las tablas de Huffman, y
% almacena el resultado en bitsum_table.
for j = 1:3,
for t = 1:3,
if HCTN(j,t)
bs = 0;
for k = fe(j):2:ff(j),
bs = bs + HCT(maxth(HCTN(j,t)+1)*min(15,IX(k))+ ...
min(15,IX(k+1))+1,2*t+6*j-7);
end
bitsum_table(j,t) = bs;
end
end
% Selecciona la tabla de Huffman que consume menos bits.
[min_bitsum,min_bitsum_index] = min(bitsum_table(j,:));
% Guarda el nmero de la tabla, en el vector table_select.
table_select(j) = HCTN(j,min_bitsum_index);
% Almacena en bitsum_region, la cantidad de bits que consume la
subregin.
bitsum_region(j) = min_bitsum;
% Calcula la cantidad de bits que consumen los valores mayores que 14.
rlbsum = length(find(IX(fe(j):ff(j)) > 14))*rlb(j);
region_linbits_sum(j) = rlbsum;
% Almacena en la matriz SHT, la tabla de Huffman seleccionada.
SHT(:,2*j-1:2*j) = HCT(:,2*min_bitsum_index+6*j-7:2*min_bitsum_index+6*j-
6);
 end
% Calcula cuntos bits de signo se usan para la regin big_values.
big_values_signbits = length(find(IX(1:big_values*2)));

% Calcula la cantidad de bits que consume el espectro cuantificado (vector

%IX).
overall_bitsum = sum(bitsum_region) + sum(region_linbits_sum) + ...
...big_values_signbits + bitsum_count1;
end

Se presenta en la Figura 5.12 el diagrama de flujo correspondiente a la funcin

Ciclo_interno(..).
 Figura 5.12
Ciclo Externo control de la distorsin
En el ciclo externo se verifica si el factor de escala para cada subbanda tiene ms distorsin que
la permitida (ruido en la seal codificada), comparando cada banda del factor de escala (scalefactor
band) con los datos previamente calculados en el anlisis psicoacstico.

Parmetros de entrada:
SFBT es la matriz de las bandas del factor de escala
IX es el vector de valores espectrales cuantificados
qquant y quantanf son los valores usados para el intervalo de cuantificacin obtenido en el
ciclo interno
scalefac_scale es un factor logartmico de cuantificacin para los factores de escala

Parmetros de salida:
XFSF es el vector de la distorsin en cada una de las bandas del factor de escala
preflag indica si la opcin de prenfasis ha sido utilizada o no

function [XFSF,preflag] = Ciclo_externo(SFBT,IX,qquant,quantanf,scalefac_scale)

global XR gr xmin scalefac_l

% La opcin de prenfasis no se implementa.

preflag = 0;

% Calcula la distorsin en las bandas del factor de escala (vector XFSF), y

%luego
% amplifica las bandas del factor de escala que exceden el umbral de
%enmascaramiento.
ifqstep = 2^(0.5*(1+scalefac_scale));
XFSF = zeros(1,21);
for sb = SFBT
for i = sb(3):sb(4),
XFSF(sb(1)) = XFSF(sb(1))+(abs(XR(i))-
IX(i)^(4/3)*2^((qquant+quantanf)/4))^2/sb(2);
end
if xmin(sb(1)) < XFSF(sb(1))
scalefac_l(sb(1),gr) = scalefac_l(sb(1),gr) + 1;
xmin(sb(1)) = xmin(sb(1))*ifqstep^(2*scalefac_l(sb(1),gr));
for i = sb(3):sb(4),
XR(i) = XR(i)*ifqstep^scalefac_l(sb(1),gr);
end
end
end

Se presenta en la Figura 5.13 el diagrama de flujo correspondiente a la funcin Ciclo_externo(..).

 Figura 5.13

Ambos ciclos son ejecutados para realizar tanto la cuantificacin no unifrome como la
codificacin huffman. La implementacin del proceso completo se muestra a continuacin:
system_const = 8; % Reinicia el valor de la constante del sistema.
% Tabla de las bandas del factor de escala segn el estndar (Para bloques
largos y 44.1 kHz) proporcionada por la ISO.
SFBT = [1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21;
4 4 4 4 4 4 6 6 8 8 10 12 16 20 24 28 34 42 50 54 76;
1 5 9 13 17 21 25 31 37 45 53 63 75 91 111 135 163 197 239 289 343;
4 8 12 16 20 24 30 36 44 52 62 74 90 110 134 162 196 238 288 342 418];

% Calcula el nmero promedio de bits disponibles para main_data, por grnulo

% (sin incluir el bit_reservoir).
% Inicializa las variables usadas para el control del formato.
%tasa es la tasa de bits que es elegida por el usuario.
init_mean_bits = fix(tasa*1000*(1152/44100)/2)-(84+ajuste);
bit_reservoir = 0;
padding_bit = 0;
rest = 0;

% Calcula los bits disponibles para cada grnulo (incluye el bit_reservoir).

mean_bits = init_mean_bits + bit_reservoir
% Chequea la mxima cantidad de bits permitida para cada grnulo.
if mean_bits > 4095
mean_bits = 4095;
end
for gr=1:2
% Si no hay datos de audio, entonces devuelve ciertos valores por
% defecto. Si se trata del primer grnulo, entonces se procesa el
% segundo grnulo. Si est procesando el segundo grnulo, entonces
% la ejecucin contina en la etapa de formato.
if XR == 0,
scalefac_scale(gr) = 0;
scalefac_l(:,gr) = zeros(21,1);
IX(:,gr) = zeros(576,1);
IS(:,gr) = zeros(576,1);
count1table_select(gr) = 0;
big_values(gr) = 0;
region0_count(gr) = 0;
region1_count(gr) = 0;
table_select(gr,:) = zeros(1,3);
preflag = 0;
global_gain(gr) = 210 - 8; % Es decir, 210-system_const.
scalefac_compress(gr) = 0;
part2_3_length(gr) = 0;
bit_reservoir = mean_bits;
S = zeros(36,32);
SHT = zeros(256,6,gr);
slen1(gr) = 0;
slen2(gr) = 0;
rlb(gr,:) = zeros(1,3);
fe(gr,:) = zeros(1,3);
ff(gr,:) = zeros(1,3);
count1(gr) = 0;
else
% Inicializacin de variables.
scalefac_scale(gr) = 0;
scalefac_l(:,gr) = zeros(21,1);

% Calcula la distorsin permitida, segn el modelo psicoacstico.

%UmbrAbs es el umbral absoluto de audicin
%UmbrEnmGl es el umbral de enmascaramiento Global que proviene del
%modelo psicoacstico
%SFBT es la tabla de bandas del factor de escala
xmin = Distorsion_permitida(SFBT,UmbrAbs,UmbrEnmGl);

% Ciclo interno. Chequea la tasa de bits. Si el vector IX requiere ms

% bits de los permitidos para ser codificado, repite el ciclo interno;
% hasta que la cantidad disponible de bits sea suficiente para
%codificar el espectro cuantificado (vector IX).
[IX(:,gr),IS(:,gr),SHT(:,:,gr),overall_bitsum,count1table_select(gr),.
,big_values(gr),region0_count(gr),region1_count(gr),table_select(gr,:)
qquant,quantanf,rlb(gr,:),count1(gr),fe(gr,:),ff(gr,:)]= ...
Ciclo_interno(XR,system_const,SFBT);
while mean_bits - 74 < overall_bitsum,
system_const = system_const - 1;
[IX(:,gr),IS(:,gr),SHT(:,:,gr),overall_bitsum,count1table_select(gr),
big_values(gr),region0_count(gr),region1_count(gr),table_select(gr,:)
,qquant,quantanf,rlb(gr,:),count1(gr),fe(gr,:),ff(gr,:)] = ...
Ciclo_interno(XR,system_const,SFBT);
end

% Ciclo externo. Chequea la distorsin. Si la distorsin mxima

% es excedida, vuelve a llamar el ciclo interno, de acuerdo con
% los requerimientos del estndar internacional ISO/IEC 11172-3.
% En este paso se incluyen las condiciones para terminar los ciclos;
% si alguna de ellas se cumple, la ejecucin de los ciclos se detiene
% y los datos obtenidos hasta ese momento son usados para la etapa de
% formato.
[XFSF,preflag] = Ciclo_externo(SFBT,IX(:,gr),qquant,quantanf,...
scalefac_scale(gr));
% Si alguna banda excede la distorsin permitida, entonces se chequean
% las condiciones para terminar los ciclos. En el caso de que las
% condiciones para terminacin de los ciclos no se cumplan, entonces
%se repite el ciclo interno.
while length(find(xmin < XFSF)) > 0,
% Chequea si todas las bandas del factor de escala ya han sido
%amplificadas, en cuyo caso se terminan los ciclos.
if length(find(scalefac_l(:,gr) ~= 0)) == 21
break
end
% Chequea el mximo de los factores de escala, teniendo en cuenta
% el campo scalefac_scale.
if (max(scalefac_l(1:11,gr))==15 | max(scalefac_l(12:21,gr))==7)...
& scalefac_scale(gr)== 0
% scalefac_scale se pone en '1' y scalefac_l se pone en '0'.
scalefac_l(:,gr) = zeros(21,1);
scalefac_scale(gr) = 1;
end
if (max(scalefac_l(1:11,gr))==15 | max(scalefac_l(12:21,gr))==7)...
& scalefac_scale(gr)==1
% Se terminan los ciclos.
break
end
% Si no se cumple ninguna condicin para la terminacin de los
%ciclos, entonces se repite el ciclo interno.
[IX(:,gr),IS(:,gr),SHT(:,:,gr),overall_bitsum,count1table_select(gr)
,big_values(gr),region0_count(gr),region1_count(gr),...
table_select(gr,:),qquant,quantanf,rlb(gr,:),count1(gr),...
,fe(gr,:),ff(gr,:)] = Ciclo_interno(XR,system_const,SFBT);
while mean_bits - 74 < overall_bitsum,
system_const = system_const - 1;
[IX(:,gr),IS(:,gr),SHT(:,:,gr),overall_bitsum,...
,count1table_select(gr),big_values(gr),region0_count(gr),...
region1_count(gr),table_select(gr,:),qquant,quantanf,rlb(gr,:),
count1(gr),fe(gr,:),ff(gr,:)]=
Ciclo_interno(XR,system_const,SFBT);
 end
[XFSF,preflag] = Ciclo_externo(SFBT,IX(:,gr),qquant,quantanf,...
scalefac_scale(gr));
end
end

% Calcula la ganancia global del sistema.

% Primero, calcula el vector IX sin realizar el redondeo (especialmente
% usado slo para este clculo).
% IXGG: IX para global_gain.
IXGG = (abs(XR)/(2^((qquant+quantanf)/4))) .^ 0.75 - 0.0946;
%Despus, calcula la informacin del intervalo de cuantizacin (vector
%iic)para cada una de las 576 muestras de audio del grnulo.
iic = zeros(576,1);
ifqstep = 2^(0.5*(1+scalefac_scale(gr)));
for h = SFBT,
for q = h(3):h(4),
iic(q) = 4*log2(abs(XR(q))*ifqstep^scalefac_l(h(1),gr)/
(abs(IXGG(q))^(4/3)));
end
end
iic(419:576)=4.*log2(abs(XR(419:576)).*ifqstep./abs(IXGG(419:576)).^(4/3));
% Por ltimo, calcula global_gain.
global_gain(gr) = round(mean(iic))+210-system_const-qquant-ajgg;

end

Si cualquiera de las bandas del factor de escala tiene ms ruido que el mximo permitido, se
amplifica esa banda de factor de escala, decrementa el tamao del paso del cuantificador para las
mismas y ejecuta ambos ciclos (el interno y el externo) de nuevo. Las llamadas a los ciclos terminan
cuando una de las siguientes condiciones se cumple:
Ninguna de las bandas del factor de escala tiene una distorsin mayor a la permitida.
Si la siguiente iteracin amplifica ms de lo permitido.
Todas las bandas han sido amplificadas al menos una vez.

CODIFICACIN DE LA INFORMACIN SECUNDARIA

Falta

FORMATO DEL FLUJO DE BITS

Falta
 OPCIN 2 -MODELO PSICOACSTICO
Si se pulsa dentro del menu principal sobre el botn MODELO PSICOACSTICO, aparecer
la ventana:

En esta opcin de la herramienta nombre del tutorial, se describe detalladamente como se

realiza cada procesamiento de la seal para llevar a cabo el Modelo Psicoacstico. En la Figura 5.14
se muestra los pasos llevados a cabo para dicho modelo.

A N L IS IS E S P E C T R A L

ID E N T IF IC A C I N D E
EN M AS C AR AD O R E S T O N ALE S Y
N O - T O N A L E S ( R U ID O S A S )

R E O R G A N IZ A C I N D E
EN M ASCAR AD OR ES

C LC U LO D E LO S U M BR ALE S
D E E N M A S C A R A M IE N T O
IN D IV ID U A L

C LC U LO D EL
E N M A S C A R A M IE N T O
GLOBAL
Figura 5.13
 Se ha implementado el Modelo Psicoacstico I, segn las especificaciones de la ISO 11172-3, este
modelo es usado en MPEG para la capa I y II; aunque realizando varios cambios, se ha ajustado
para la capa III ( mp3 ).
El Modelo Psicoacstico I determina el mximo nivel de ruido permitido en cada subbanda, de
tal forma que por debajo de este nivel, resulta inaudible cualquier componente ruidosa, y por tanto
puede ser despreciada. Este valor determinar la cantidad mxima de ruido de cuantificacin.
Para concretar, la finalidad de este bloque es estimar el umbral de enmascaramiento global
mediante la combinacin de los umbrales de enmascaramiento individual de componentes tonales y
no-tonales. Se separan las componentes tonales de las componentes de ruido en la seal de audio
debido a que cada componente presenta un tipo de enmascaramiento diferente.
El modelo I identifica las componentes tonales basado en los picos locales del espectro de
potencias. Despus de procesar todas las componentes tonales, el modelo concentra los valores
espectrales restantes en una nica componente no-tonal por banda crtica. El ndice de frecuencia de
cada una de estas componentes no-tonales es el valor ms cercano a la media geomtrica de la
banda crtica a la cual pertenece cada componente no-tonal.

La implementacin paso a paso de cada bloque representado en la Figura 5.13 es la siguiente:

PASO 1 : ANLISIS ESPECTRAL
El objetivo de este paso es obtener una alta resolucin espectral de la seal de entrada, con los
componentes del espectro expresados en trminos de nivel de presin acstica (SPL). Una
estimacin de la densidad espectral de potencia, P(k), sera:
2 kn
N 1 j
N 2 N
P k = PN 10log 10 w n x ne 0k
n=0 2

PN es el trmino de potencia normalizada cuyo valor es 90.302 dB

N=1024 es la cantidad de puntos sobre los que realizar la transformacin
w(n) es una ventana hanning que se aplica para evitar las discontinuidades
en los extermos de la seal

%y son las muestras del archivo wav

%UAA es el umbral absoluto de audicin
%fs es la frecuencia de la seal
longfft=1024;
constantnorma=90.302;
f=[1:longfft/2]*(fs/longfft);
UAA=3.64.*(f./1000).^(-.8)-6.5.*exp(-0.6.*(f./1000-3.3).^2)
+0.001.*(f./1000).^4;
potencia=dsp(y, longfft, constantnorma);
%solo es necesario representar la mitad de la densidad espectral debido a la
%simetria de la fft
potencia=potencia(1:512);

function p = dsp(muestras, longfft, const)

% dsp toma una seal y computa su densidad espectral de potencia

%Realiza la fft sobre los puntos definidos por longfft,traspasa el valor a
%decibelios y le aade la constante const para normalizar la energia.

p=const+10.*log10((abs(fft(muestras,longfft))).^2);
end

En la Figura 5.14 queda representado la densidad espectral de potencia y el umbral absoluto de

audicin. En la parte superior de la Figura 5.14 se presenta la densidad espectral de potencia y el
umbral absoluto de audicin en unidades de frecuencia Hz, en la parte inferior en bark.
Para simplificar los clculos, los valores espectrales se procesan en unidades perceptuales (el
bark, relacionado con el ancho de las bandas crticas).

function barks = hzabark(hz)

%hzabark cambia la frecuencia en unidades de Hz a barks.
barks=13*atan(.00076*hz)+3.5*atan((hz/7500).^2);
end

Figura 5.14

PASO 2: IDENTIFICACIN DE ENMASCARADORES TONALES Y NO-TONALES

(RUIDOSAS)
Despus de la estimacin de la DSP (densidad espectral de potencia), se identifican las
componentes enmascarantes tonales y no-tonales. Este modelo identifica las componentes
tonales basado en picos locales dentro de un rango de frecuencias, y segn estos criterios:

1. Si P(k) > P(k - 1) y P(k) >= P(k + 1) siendo P(k) una lnea espectral

2. Si P(k) > P(k + j) + 7dB y P(k )> P(k - j) + 7dB

 Donde j es elegido de acuerdo a:

j= -2,+2 para 2< k < 63 (0 kHz< f <=2.756kHz)

j= -3,-2,+2,+3 para 63<= k<127 ( 2.756 kHz< f <=5.512kHz)

j= -6,...,-2,+2,...,+6 para 127<= k<255 (5.512 kHz< f <=11.024 kHz)

j= -12,...,-2,+2,...,+12 para 255<= k<500 (11.024 kHz< f <=19.982kHz)

Por cada lnea espectral que cumpla con estos criterios, se listan los siguientes parmetros:
. El ndice k de la lnea espectral
. La bandera tonal (tonal flag)
1
. P TM k =10log 10 100.1P k j dB
j=1

Despus de procesar todas las componentes tonales, el modelo concentra los valores
espectrales restantes en una nica componente no-tonal por banda crtica. El ndice de
frecuencia de cada una de estas componentes no-tonales es el valor ms cercano a la media
geomtrica de la banda crtica a la cual pertenece cada componente no-tonal.
Los siguientes parmetros son listados:
. El ndice K de la lnea espectral ms cerca de la media geomtrica de la banda crtica
. La bandera No tonal (NON Tonal Flag)
0.1P j
. P NM k =10log 10 10 dB
j

global f potencia UAA;

figure;
subplot(2,1,1);
tono_dsp=encontrar_tonos(potencia);
tonoloc=find(tono_dsp);
stem(f(tonoloc), tono_dsp(tonoloc), 'x');
hold on;
plot(f, potencia, 'b');
plot(f, UAA, 'r--');
xlabel('Frecuencia (Hz)');
ylabel('Magnitud (SPL)');
title('Componentes Tonales Enmascarantes');
grid;

subplot(2,1,2);
stem(b(tonoloc), tono_dsp(tonoloc), 'x');
hold on;
plot(b, potencia, 'b');
plot(b, UAA, 'r--');
xlabel('Frecuencia (Bark)');
ylabel('Magnitud (SPL)');
title('Componentes Tonales Enmascarantes');
grid;
ruido_dsp=zeros(1,length(tono_dsp));
limitinf=1;%limite inferior de la banda crtica
limitsup=max(find(b<1));%limite superior de la banda crtica

for band = 1:26

[ruido_dsp_loc, loc]=ruido_enmascarador(potencia, tono_dsp, limitinf,
limitsup);
if (loc ~= -1)
ruido_dsp(floor(loc))=ruido_dsp_loc;
end
limitinf=limitsup;
limitsup=max(find(b<(band+1)));
end

figure;
ruidoloc=find(ruido_dsp);
subplot(2,1,1);
stem(f(ruidoloc), ruido_dsp(ruidoloc), 'o');
hold on;
plot(f, potencia, 'b');
plot(f, UAA, 'r--');
xlabel('Frecuencia (Hz)');
ylabel('Magnitud (SPL)');
title('Componentes No-Tonales (Ruidosas) Enmascarantes');
grid;

subplot(2,1,2);
stem(b(ruidoloc), ruido_dsp(ruidoloc), 'o');
hold on;
plot(b, potencia, 'b');
plot(b, UAA, 'r--');
xlabel('Frecuencia (Bark)');
ylabel('Magnitud (SPL)');
title('Componentes No-Tonales (Ruidosas) Enmascarantes');
grid;

function tono_dsp = encontrar_tonos(P)

% Densidad_espectral_potencia_tonos =
encontrar_tonos(Densidad_espectral_potencia_seal)

% encontrar_tonos toma la potencia espectral, encuentra los tonos, y devuelve

%un espectro solamente con los tonos intactos. Estos valores se obtienen
%promediando los tonos en las bandas adyacentes.
% Primero inicializamos tono_dsp
tono_dsp=zeros(1,length(P));
% recorremos el espectro
for k=1:length(P),
% Comprobamos si la componente en k es un tono.
if(es_tono_enmascarador(P,k))
% coloca el tono en la salida del espectro con su nuevo valor.
tono_dsp(k) = 10*log10(dbinv(P(k-1))+dbinv(P(k))+dbinv(P(k+1)));
end
end
% *************************************************************
function bool = es_tono_enmascarador(P, k)
% boolean = es_tono_enmascarador(potencia_espectral, ndice)
%
% es_tono_enmascarador comprueba la potencia espectral P en el ndice k y
%devuelve un booleano indicando si es un tono.
%Si P(k) es un mximo local y mayor de 7 dB en una banda adyacente, es un tono.
% Este concepto de adyacente se define como:
% j=-2, 2 --- 2 < k < 63
% j=-2,-3,3,2--- 63 <= k < 127
% j=-6,-5,...,-2, 2,..,5,6--- 127 <= k < 255
% j=-12,-11,...,-2,...,11,12--- 255 <= k <= 500
% Si est al principio o al final de P (donde se requiere una longitud de 12),
entonces no es un mximo local)
if ((k<=1) | (k>500))
bool = 0;
% Si no es un mximo local, salimos con bool=0;
elseif ((P(k)<P(k-1)) | (P(k)<P(k+1))),
bool = 0;
% Si no, necesitamos comprobar si hay un mximo en su banda adyacente;
elseif ((k>2) & (k<63)),
% Para frecuencias entre 0-2.756kHz
bool = ((P(k)>(P(k-2)+7)) & (P(k)>(P(k+2)+7)));
elseif ((k>=63) & (k<127)),
% Para frecuencias entre 2.7-5.512Khz
bool = ((P(k)>(P(k-2)+7)) & (P(k)>(P(k+2)+7)) & (P(k)>(P(k-3)+7)) &
(P(k)>(P(k+3)+7)));
elseif ((k>=127) & (k<255)),
% Para frecuencias entre 5.512-11.024Khz
bool = ((P(k)>(P(k-2)+7)) & (P(k)>(P(k+2)+7)) & (P(k)>(P(k-3)+7)) &
(P(k)>(P(k+3)+7)) & (P(k)>(P(k-4)+7)) & (P(k)>(P(k+4)+7)) & (P(k)>(P(k-5)+7)) &
(P(k)>(P(k+5)+7)) & (P(k)>(P(k-6)+7)) & (P(k)>(P(k+6)+7)));
% Para frecuencias entre 11.024-19.982Khz
elseif (255<=k & k<=500)
bool = ((P(k)>(P(k-2)+7)) & (P(k)>(P(k+2)+7)) & (P(k)>(P(k-3)+7)) &
(P(k)>(P(k+3)+7)) & (P(k)>(P(k-4)+7)) & (P(k)>(P(k+4)+7)) & (P(k)>(P(k-5)+7)) &
(P(k)>(P(k+5)+7)) & (P(k)>(P(k-6)+7)) & (P(k)>(P(k+6)+7)) & (P(k)>(P(k-7)+7))
& (P(k)>(P(k+7)+7)) & (P(k)>(P(k-8)+7)) & (P(k)>(P(k+8)+7)) & (P(k)>(P(k-
9)+7)) & (P(k)>(P(k+9)+7)) & (P(k)>(P(k-10)+7)) & (P(k)>(P(k+10)+7)) &
(P(k)>(P(k-11)+7)) & (P(k)>(P(k+11)+7)) &(P(k)>(P(k-12)+7)) &
(P(k)>(P(k+12)+7)));
else
bool = 0;
end

function [ruido_dsp, loc] = ruido_enmascarador(P, Ptm, inf, sup)

% [dsp_de_ruidoloc, situacin dentro de la banda
% crtica]= ruido_enmascarador(densidad_espectral_potencia,
%densidad_espectral_potencia_tonos, lmite_inferior_banda_crtica,
%lmite_superior_banda_crtica)

% ruido_enmascarador toma la potencia de un espectro y el espectro de un tono,

as como los rangos inferior y superior a tratar (de manera que posteriormente
se puede especificar una banda crtica), y devuelve un valor relativo a la
localizacin del ruido enmascarador.
%
% Si loc=-1, No hay ruido enmascarador en la regin.
% Este array this array indica si un elemento dado es parte del ruido. Se
inicializa con unos.
comp_ruidosas=ones(1,sup-inf+1);
% recorremos el espectro de tonos
for k=inf:sup,
% Si hay un tono
if (Ptm(k)>0),
% comprobamos la localizacin frecuencial y determinamos la distancia a la
%banda adyacente
if ((k>2) & (k<63))
m=2;
elseif((k>=63) & (k<127))
m=3;
 elseif((k>=127) & (k<255))
m=6;
elseif((k>=255) & (k<500))
m=12;
else
m=0;
end
% Ponemos todos los componentes de la banda adyacente a 0, lo que provoca la
%eliminacin de ellos en la lista de componentes de ruido.
for n=(k-inf+1)-m:(k-inf+1)+m,
if (n > 0)
comp_ruidosas(n)=0;
end
end
end
end
% Los ndices en comp_ruidosas que tienen un 1 son parte de los ruidos
%enmascaradores.
% Recorremos las posiciones de los ruidos y realizamos una suma en potencia, lo
%que requiere una conversin de la magnitud (los dB's no se suman linealmente),
%si no hay componentes de ruido en el rango, entonces salimos.
if (isempty(find(comp_ruidosas)))
ruido_dsp=0;
loc=-1;
else
temp=0;
for k=(inf+find(comp_ruidosas)-1)
temp = temp + dbinv(P(k));
end
% Convertimos la suma a escala logartmica
%geomean es la media geomtrica
ruido_dsp=10*log10(temp);
loc=geomean(inf+find(comp_ruidosas)-1);
end

En la Figura 5.15 se muestran las componentes tonales y no tonales enmascarantes (azul)

identificadas como se ha deducido en la implementacin anterior y el umbral de audicin del
sistema auditivo (rojo).

Figura 5.15

PASO 3: REORGANIZACIN DE ENMASCARADORES

Hasta ahora tenemos localizados las componentes enmascarantes tonales y no-tonales; en este
 paso el modelo reduce el nmero de estos enmascaradores segn los criterios:

I. Si una componente enmascarante tonal o no-tonal se encuentra por debajo del umbral de
audicin, se elimina; ya que no seremos capaces de percibir ningn sonido por debajo de
dicho umbral.

II. Si dentro de una banda crtica a una distancia de 0.5 bark (por arriba o por debajo de dicha
banda), se encuentran dos componentes enmascarantes (tonales o no-tonales), una de ellas
ser eliminada, la ms dbil.

Este ultimo criterio, se puede entender como fenmeno de enmascaramiento. Existen tres
tipos de enmascaramiento: Ruido enmascara tono (NMT), tono enmascara ruido(TMN) y
ruido enmascara ruido (NMN), conceptos que se estudiaron en el captulo 3.

La implementacin en Matlab para llevar a cabo este paso es la siguiente:

%tono_dsp y ruido_dsp fueron calculados en el paso 3

[tono_dsp, ruido_dsp]=comprobar_enmascaradores(tono_dsp, ruido_dsp, UAA, b);
tonoloc=find(tono_dsp);
subplot(2,2,3);
stem(b(tonoloc), tono_dsp(tonoloc), 'x');
hold on;
plot(b, potencia, 'b');
plot(b, UAA, 'r--');
xlabel('Frecuencia (Bark)');
ylabel('Magnitud');
title('Componentes Tonales organizadas');
grid;
ruidoloc=find(ruido_dsp);
subplot(2,2,4);
stem(b(ruidoloc), ruido_dsp(ruidoloc), 'o');
hold on;
plot(b, potencia, 'b');
plot(b, UAA, 'r--');
xlabel('Frecuencia (Bark)');
ylabel('Magnitud');
title('Componentes No-Tonales organizadas');
grid;

function [tono_dsp_sobre_UAA, ruido_dsp_sobre_UAA]=

comprobar_enmascaradores(tono_dsp, ruido_dsp, UAA, b)
% [tonos_enmascaradores,Ruidos_enmascaradores] =
%comprobar_enmascaradores(densidad_espectral_potencia_tonos,
% densidad_espectral_potencia_ruido,Umbral_absoluto_audicin,array_bark)

% comprobar_enmascaradores toma la potencia espectral del enmascarador y

%comprueba si los valores estn sobre el unmbral absoluto de audicin (UAA). En
%caso negativo, el enmascarador es elminado porque no ser escuchado. Luego
%localiza el enmascarador que contienen otros enmascaradores dentro de su banda
%crtica. Si se encuentra alguno, el ms bajo de ellos se iguala a cero, porque
%no sern detectados por el odo humano.

tono_dsp_sobre_UAA=tono_dsp.*(tono_dsp>UAA);
ruido_dsp_sobre_UAA=ruido_dsp.*(ruido_dsp>UAA);
% Los enmascaradores que permanecen deben ser chequeados para comprobar si
%alguno de ellos estn en el ancho de banda de una banda crtica. En caso
%afirmativo, solo el de mayor potencia importa, los otros pueden igualarse a
%cero.
% recorrer la lista de enmascaradores
for j=1:length(UAA),
tono_encontrado=0;
ruido_encontrado=0;

% Se encontr algn tono o ruido enmascarador?

if (tono_dsp_sobre_UAA(j)>0)
tono_encontrado=1;

end
if (ruido_dsp_sobre_UAA(j)>0)
ruido_encontrado=1;

end
% Si un enmascarador ha sido detectado
if (tono_encontrado | ruido_encontrado)
enmascarador_loc_bark = b(j);
% determina los umbrales superior e inferior de la banda crtica.
crit_bw_inf = enmascarador_loc_bark-0.5;
crit_bw_sup = enmascarador_loc_bark+0.5;
% determina qu valores corresponden a esos ndices
inf_loc = max(find(b<crit_bw_inf));
if (isempty(inf_loc))
inf_loc=1;
else
inf_loc=inf_loc+1;
end
sup_loc = max(find(b<crit_bw_sup));
% en este punto, conocemos la localizacin del enmascarador y su banda crtica.
%Dependiando de qu tipo de enmascarador es.
% Recorremos y eliminamos los enmascaradores de menor potencia dentro de la
%banda crtica.
% recorrer el ancho de banda de la banda crtica
for k=inf_loc:sup_loc,
if (tono_encontrado)
% encontrar otros tonos enmascaradores dentro del ancho de banda de la banda
crtica
if ((tono_dsp_sobre_UAA(j) < tono_dsp_sobre_UAA(k)) & (k ~= j)),
tono_dsp_sobre_UAA(j)=0;
break;
elseif (k ~= j)
tono_dsp_sobre_UAA(k)=0;
end
% encontrar ruidos enmascaradores en la banda crtica.
if (tono_dsp_sobre_UAA(j) < ruido_dsp_sobre_UAA(k)),
tono_dsp_sobre_UAA(j)=0;
break;
else
ruido_dsp_sobre_UAA(k)=0;
end
elseif (ruido_encontrado)
% encontrar otros ruidos enmascaradores en la banda crtica
if ((ruido_dsp_sobre_UAA(j) < ruido_dsp_sobre_UAA(k)) & (k ~= j))
ruido_dsp_sobre_UAA(j)=0;

break;
elseif (k ~= j)

ruido_dsp_sobre_UAA(k)=0;

end
% encontrar tonos enmascaradores en la banda crtica
if (ruido_dsp_sobre_UAA(j) < tono_dsp_sobre_UAA(k)),

ruido_dsp_sobre_UAA(j)=0;

break;
else
tono_dsp_sobre_UAA(k)=0;
end
end
end
end
end
end

En la Figura 5.16 se muestran las componentes tonales y no tonales enmascarantes

organizadas. En las esquinas superiores se muestran dichas componentes sin organizar segn
los criterios mencionados en este paso, y en las inferiores se muestran ya organizadas. De esta
forma se puede ver el efecto de la eliminacin del nmero de estos enmascaradores que a
efectos sonoros es imprecedible para el sistema auditivo humano.

Figura 5.16

PASO 4 :CLCULO DE LOS UMBRALES DE ENMASCARAMIENTO INDIVIDUAL

Despus de obtener una estimacin de la situacin de componentes tonales y no-tonales
enmascarantes, lo siguiente que se realiza es la obtencin del enmascaramiento individual de
cada componente tonal y no-tonal enmascarante. Cada umbral individual representa una
componente enmascaradora en un ndice frecuencial i, debido al tono o ruido enmascarador
situado en el ndice frecuencial j. El umbral de enmascaramiento tonal T TM i , j y el
umbral de enmascaramiento no-tonal T NM i , j , vienen dado por:
 T TM i , j= P TM j 0.275z j SF i , j 6.025 dB

T NM i , j= P NM j 0.175z j SF i , j 2.025 dB

Donde P TM j y P NM j denotan el nivel de presin acstica (SPL) del enmascarador

tonal, no-tonal respectivamente; en el ndice frecuencial j, z(j) el ndice frecuencial j en Bark;
y la envergadura del enmascaramiento desde el ndice enmascarador j al ncide i, SF(i,j) se
modela por la siguiente expresin:
SF(i,j) = 17deltaz 0.4* P TM j +11 para -3 <= deltaz < -1
(0.4* P TM j +6)deltaz para -1 <= deltaz < 0
-17deltaz para 0 <= deltaz < 1
(0.15* P TM j -17)deltaz - 0.15* P TM j para 1 <= deltaz < 8

deltaz es la diferencia en Barks entre la localizacin de una componente enmascarada y una

enmascarante (deltaz= z(i)-z(j)).

La implementacin en Matlab es la siguiente:

global tono_dsp ruido_dsp UAA b umbral_tonal umbral_no_tonal;

[umbral_tonal,umbral_no_tonal]=umbral_individual(UAA, tono_dsp, ruido_dsp, b);

function
[umbrtonal,umbnotonal]=umbral_individual(Umbral_absoluto_enmascaramiento,
densidad_espectral_potencia_tono,densidad_espectral_potencia_ruido,
frecuencias_en_bark)
%devuelve los umbrales tonales,no-tonales para reutilizacion del algoritmo en
el siguiente paso
% El umbral absoluto toma el umbral absoluto de audicin, as como las
densidades espectrales de ruido y tonos para determinal el umbral de
enmascaramiento individual. Este mtodo supone que los efectos de
enmascaramiento son aditivos, de manera que las mscaras de todos los
enmascaradores y los umbrales absolutos se suman conjuntamente.
% Se inicializa a cero
umbrtonal=zeros(1,length(potencia_tono));
figure;
hold on;
plot(b(find(potencia_tono)), potencia_tono(find(potencia_tono)), 'rx');
grid;
% recorremos la lista de tonos
for k=find(potencia_tono)
% Determina los umbrales de enmascaramiento alrededor del tono
[umbral, start]=umbral_enmascaramiento(1,k,potencia_tono(k),b);
plot(b(start:start+length(umbral)-1), umbral);
grid;
% suma la potencia del umbral a temp en el rango de frecuencia adecuado
umbrtonal(start:start+length(umbral)-1)=umbrtonal(start:start+length(umbral)-
1)+dbinv(umbral);
end
plot(b,10*log10(umbrtonal), 'c');
xlabel('Frecuencia (Bark)');
ylabel('Energa (dB)');
title('Umbral de Enmascaramiento Tonal');
grid;
umbrnotonal=zeros(1,length(potencia_ruido));
figure;
hold on;
plot(b(find(potencia_ruido)), potencia_ruido(find(potencia_ruido)), 'ro');
grid;
% recorremos la lista de ruido
for k=find(potencia_ruido)
% determina el umbral de enmascaraminto alrededor del ruido enmascarador
[umbral, start]=umbral_enmascaramiento(0,k,potencia_ruido(k),b);
plot(b(start:start+length(umbral)-1), umbral);
grid;
% suma la potencia del umbral a temp en el rango de frecuencia adecuado
umbrnotonal(start:start+length(umbral)-1)=
umbrnotonal(start:start+length(umbral)-1)+dbinv(umbral);
end
plot(b,10*log10(umbrnotonal), 'c');
xlabel('Frecuencia (Bark)');
ylabel('Energa (dB)');
title('Umbral de Enmascaramiento No-Tonal');
grid;

function [umbral comienzo] = umbral_enmascaramiento(tipo, j, P, b)

% [umbral_enmascarante, comienzo_intervalo] = umbral_enmascaramiento(tipo,
loc_enmas,dsp_j, bark)
% umbral_enmascaramiento devuelve un array con el umbral de enmascaramiento en
dB SPL localizado alrededor del intervalo de frecuencia
% comienzo es el ndice de comienzo del umbral
%El usuario tambin debe proporcionar la densidad espectral de potencia y el
%interbalo de frecuencia en bark.
%En el caso de que se desee averiguar umbrales diferentes, es necesario saber
%donde comienza cada uno de ellos
%Es posible calcular dos umbrales diferentes, que el usuario debe especificar:
%
%
% tipo = 0 umbral = umbral de ruido
% tipo = 1 umbral = umbral del tono
%
% Este umbral se determina en un rango de -3 a 8 bark de la componente
%enmascarante

% se localiza la componente enmascarante en barks

enmascloc=b(j);

% Se crea el rea de distribucin de la funcin resultante en barks

inf=enmascloc-3;
sup=enmascloc+8;
% intervalo discreto
limitinf=max(find(b<inf));
if (isempty(limitinf))
limitinf = 1;
end
limitsup=max(find(b<sup));

% se calcula la funcin de dispersin

SF = funcion_dispersin(j, P, limitinf, limitsup, b);

if (tipo==0)
% se calcula el umbral de enmascaramiento ruidoso o no-tonal
umbral=P-.175*b(j)+SF-2.025;
else
 % se calcula el umbral de enmascaramiento tonal
umbral=P-.275*b(j)+SF-6.025;
end

comienzo=limitinf;

% -----------------------------------------------------------------
function dispersion = funcion_dispersin(intervalo_enmasc, potencia, inf, sup,
b)
% envergadura_alrededor_del_enmascarante = funcion_dispersin(intervalo_enmasc,
potencia_enmasc,limite_inf, limite_sup, bark)
%
% funcion_dispersin toma el intervalo de la componente enmascarante y su
potencia para determinar la funcin de dispersin alrededor del mismo.
%Esta funcin indica el nivel mnimo que deben alcanzar las frecuencias
%cercanas antes de que sean detectables por el oido humano
%Se usa la funcion de dispersion para determinar si una seal es audible por
encima de la componente enmascarante.
% deltaz es la diferencia en barks entre la localizacin de una componente
enmascarada (zi) y una enmascarante(zj) deltaz= zi-zj

zj_bark=b(intervalo_enmasc);

for i=inf:sup,
zi_bark=b(i);
deltaz=zi-zj;

if ((deltaz>=-3.5) & (deltaz<-1))

dispersion(i-inf+1)=17*deltaz-0.4*potencia+11;
elseif ((deltaz>=-1) & (deltaz<0))
dispersion(i-inf+1)=(0.4*potencia+6)*deltaz;
elseif ((deltaz>=0) & (deltaz<1))
dispersion(i-inf+1)=-17*deltaz;
elseif ((deltaz>=1) & (deltaz<8.5))
dispersion(i-inf+1)=(0.15*potencia-17)*deltaz-0.15*potencia;
end
end

En la Figura 5.17 se muestran los umbrales de enmascaramiento individual para componentes

tonales a la izquierda y para componentes no-tonales a la derecha.
 Figura 5.17

PASO 5 :CLCULO DEL ENMASCARAMIENTO GLOBAL

En este paso, se utiliza el umbral de enmascaramiento individual para obtener el umbral de
enmascaramiento global, concluyendo asi con el objetivo. El modelo asume que los efectos de
enmascaramiento son aditivos. El umbral global de enmascaramiento, T g i , se obtiene
calculando la suma :

L M
0.1T q i 0.1T TM i ,l 0.1T NM i ,m
T g i= 10log 10 10 10 10 dB
l=1 m=1

donde T q i es el umbral absoluto de audicin para el intervalo frecuencial i, T TM i , l

y T NM i , m son los umbrales de enmascaramiento individual calculados en el paso 4, y L
y M son el nmero de componentes tonales y no-tonales, respectivamente, identificados en el
paso 3.
La implementacin en Matlab es la siguiente:
function total = global_umbral2(UAA, potencia_tono, potencia_ruido, b)

temp1=zeros(1,length(potencia_tono));

for k=find(potencia_tono),

[thres, start]=mask_threshold(1,k,potencia_tono(k),b);

temp1(start:start+length(thres)-1)=temp1(start:start+length(thres)-
1)+dbinv(thres);
end

temp2=zeros(1,length(potencia_ruido));

for k=find(potencia_ruido),

[thres, start]=mask_threshold(0,k,potencia_ruido(k),b);

temp2(start:start+length(thres)-1)=temp2(start:start+length(thres)-
1)+dbinv(thres);
end

temp=temp1+temp2;

for k=1:length(UAA),
temp(k)=temp(k)+dbinv(UAA(k));
end

total=10*log10(temp)
En la Figura 5.18 se aprecia el resultado final al modelo psicoacstico, determinar el umbral
de enmascaramiento global para cada subbanda.

Figura 5.18