Compresión de Datos

Transcripción

Compresión de Datos

Compresión de Datos
Introducción
Introducción
¿Por qué es importante conocer sobre
Compresión?
¿Qué conceptos involucra?
¿Por qué es importante conocer
sobre Compresión?
Cada vez más información se maneja en forma
digital (Redes Sociales, digitalización de
documentos).
●Cada vez se necesita más capacidad de
almacenamiento y transmisión de información
(cloud computing)
●Cada vez se requiere un mejor uso de los recursos
(tv-digital, telefonía IP).
●
FIUBA
Organización de Datos - Curso Servetto
3
¿Qué area de la ciencia aplica?
●
●
FIUBA
La compresión como álgebra, análisis
matemático, probabilidad y estadística y
algoritmia aplicados.
Aplica a Teoría de la Información.
4
¿Qué conceptos
involucra?Teoría de la
Información
●
Información (definición epistemológica)
●
●
Datos Interpretados.
Datos
●
Característica (dimensión) + Valor (medida)
COLOR = ROJO
FIUBA
5
Teoría de la Información
●
Información (definición cuantitativa)
●
Teorema de Shannon 1948 – matemática
estadística.
●
●
PROBABILIDAD = ENTROPIA
Información (definición analítica)
●
Teorema de muestreo de Nyquist-Shannon 1949 –
matemática analítica.
●
FIUBA
TRANSFORMACIÓN
6
Teoría de la Información
●
Información (definición cuantitativa)
●
FIUBA
Shannon 1948 – matemática estadística.
7
Teoría de la información
(matemática estadística)
●
Entropía (definición estadístical)
●
●
●
FIUBA
Teorema Shannon (información promedio).
Dentro de una fuente F, recibimos el símbolo Fi, que
tenía probabilidad pi
H(F) es la entropía de toda la fuente F
8
Teoría de la información
(matemática analítica)
●
Transformada (definición analítica)
●
●
●
FIUBA
Teorema de muestreo de Nyquist-Shannon 1949 (se
puede representar con elementos discretos la misma
información que con elementos contiuos).
=> 0111010101011100101
No importa el medio de transmisión, la información
es cuantificable.
9
Representación de los Datos
(códigos de representación).
●
Dentro de un medio digital, podemos representar
la información de diferentes formas.
COLOR = ROJO (texto)
677976798232613282797479 (ASCII)
0010000000100011110100010100001100010100101000010100110000010100111101000101001000
1000110011101111100001101111001010
FIUBA
(Binario comprimido)
10
●
La representación resultante puede ser
–
sin pérdida de información (existe un proceso inverso que
reconstruye exactamente los datos originales – o la
representación original).
–
“HOLA” => 01011101010100100 => “HOLA”
–
con pérdida (no se puede reconstruir con exactitud, pero
se tiene control del error cometido).
–
=> 01010101111001 =>
FIUBA
11
●
Clasificación por longitud
–
Longitud Fija
●
Los ASCII:
0011 1000
0011 1110
–
Longitud Variable:
●
Los UNICODE variables:
100 1110
110 101000
FIUBA
12
●
Clasificación por Instantaneidad
–
Código instantáneo es aquel que no debe esperar a que
lleguen más códigos para identificarlo (es inconfundible).
00, 01,11
–
Código no instantáneo es aquel que requiere de identificar
al código siguiente, o parte de aquél, para reconocerlo.
0, 01, 11
 00111
FIUBA
13
●
Códigos Prefijos
–
Son aquellos en donde un código no puede conformar el
comienzo de otro.
●
No Prefijo
●
A = 010111
B = 0100
Prefijo
A = 001111
B = 0001
FIUBA
C = 1000
D = 10
C = 010
D = 10
–
Los códigos prefijos son instantáneos.
–
Los códigos prefijos son unívocamente decodificables.
14
●
Redundancia en la representación:
–
Códigos Tipo A:
A = 00001
E = 00010
I = 00100
O = 01000
U = 10000
–
Códigos Tipo B:
A = 001
E = 011
I = 100
O = 101
FIUBA
U = 110
15
Referencias
●
FIUBA
David Salomon , “A Concise Introduction to Data
Compression ”, Springer-Verlag London Limited
2008 , pp 21-29.
16
Algoritmos de Codificación
●
●
●
●
FIUBA
Son algoritmos para modificar la representación
de una fuente.
La representación resultante es sin pérdida de
información.
Generan códigos prefijos.
Para permitir la descompresión pueden necesitar
información de control extra.
17
●
Clasificación según la forma de reconocer la
redundancia
●
Estadístico
–
●
Run-Length
●
Por Diccionario
–
FIUBA
Los códigos aproximan a la representación del teorema de
Shanon
Los códigos se generan en base a la repetición de
mensajes. No aplica la teoría de Shanon.
18
Algoritmos de
Codificación(Cont.)
●
Clasificación según la forma de reconocer la
redundancia
●
●
Predictor
–
Lleva un registro de lo ya procesado y aplica un algoritmo
para predecir (puede acertar o no) los que vendrán.
–
Pueden utilizar la técnica de múltiples contextos: que utiliza
la probabilidad condicional, modificando la fórmula de
Shanon, y aumenta las probabilidades de aparición,
generando códigos más cortos (comprimiendo más).
Híbrido
–
FIUBA
Combina algoritmos de diferentes características
(Estadístico, por Diccionario, etc.)
19
●
Clasificación según la forma de procesar los datos
●
FIUBA
Estático
–
Genera una sola vez los códigos y se producen reemplazos
idénticos en todo el proceso de compresión.
–
En general necesita procesar dos veces a toda la fuente (o
archivo) para definir los códigos.
–
Los códigos generados son los más cortos que el algoritmo
puede generar.
20
Algoritmos de
Codificación(Cont.)
●
Clasificación según la forma de procesar los datos
●
FIUBA
Dinámico
–
Los códigos se generan en base a un supuesto inicial que se
va modificando a medida que avanza la compresión.
–
Genera códigos distintos y se producen reemplazos
diferentes dureante el proceso de compresión.
–
Los códigos generados, en general, mejoran con el avance
de la compresión.
21
Formas de Finalizar un Archivo
comprimido
●
Conteo de Emisiones
●
●
Se guarda un valor, que se lee al principio, para
identificar la cantidad de códigos generados.
Entonces se procesa realizando una cuenta
regresiva, cuando llega a cero se finaliza.
Relleno de bits(Padding)
●
Se completan los bits faltantes para que el archivo
tenga longitud entera de bytes (si ya la tiene se le
agrega un byte maś) con ceros (“0”) y un uno (“1”).
(Con algunos compresores no tiene sentido esta
técnica) . Ejemplo: 01010101 01011000
FIUBA
22
Formas de Finalizar un Archivo
comprimido(Cont.)
●
Mensaje Especial
●
●
FIUBA
Se agrega un caracter especial en el diccionario,
cuya aparición significa el fin del archivo. Entonces
cuando se termina el archivo original se realizar una
compresión más, como si apareciese ese caracter.
Ej: caracter especial “EOF”.
23
Algoritmos de
Compresión Sin
Pérdida
(Lossless)
Estadísticos
Por Diccionario
Predictores
Híbridos
FIUBA
24
Algoritmos de
Compresión
Estadísticos
Algoritmo de Huffman
Algoritmo Aritmético
FIUBA
25
(Estadístico)
FIUBA
26
(Estadístico)
●
Árbol de generación de códigos.
●
●
●
●
●
FIUBA
Genera Códigos Prefijos de longitud variable.
Esos códigos aproximan a las longitudes calculadas
por el Teorema de Shannon en bits enteros y no
existe arbol capaz de generar codigos con emision
de bits enteras mejores que Huffman.
Utiliza un árbol para generar los códigos.
En las hojas del árbol están los caracteres posibles
de comprimir.
El camino desde la raiz hacia las hojas define el
código que reemplazará al caracter.
27
(Estadístico)
Árboles de Huffman
●
Se generan en función de las veces que aparece un
caracter en el archivo (frecuencia); cuanto más aparece,
más cerca de la raíz está y códigos más cortos de
reemplazo tiene.
●
●
Por ejemplo, si se tiene el siguiente árbol:
FIUBA
28
(Estadístico)
Las codificaciones de los símbolos son:
●
–A:
000 B: 001 C: 01 D: 1
Como se basa en la frecuencia solamente es un
compresor Estadístico.
●
FIUBA
29
(Estadístico)
Construcción paso a paso fuente JERRYRICE:
●
Se utiliza una lista con par(simbolo,frecuencia), ordenada por
frecuencia.
●
Se unen los nodos con menor frecuencia, para generar el nodo
padre.
●
El nodo padre que se cree en cada paso, tendra como hijo
izquierdo al primero de la lista y derecho al segundo.
●
En caso de haber un nodo de igual frecuencia al agregar, se
agrega al final de esa repeticion de frecuencias(mejorar la longitud
de los codigos)
●
FIUBA
30
(Estadístico)
Construcción paso a paso fuente JERRYRICE:
●
●
Se obtienen las frecuencias de cada símbolo.
●
1) Se genera un nodo con C e I como hijos(frecuencia 2, por lo que van a continuacion de la E).
●
2) Se genera un nodo con J e Y como hijos(frecuencia 2, por lo que van a continuacion de la C-I).
3) Se genera un nodo con E y C-I como hijos(frecuencia 3, por lo que van a continuacion de la R). Si hubiesemos
puesto en primer lugar a C-I y J-Y en la tabla(antes que la E), hubiesemos tenido al momento de armar un nodo
padre 4 simbolos a una distancia 2 del mismo padre(codigos mas largos).
●
●
4) Se genera un nodo con J-Y y R.
●
5) Se genera el ultimo nodo, que es la raiz del arbol(con nodos hijo, E-C-I y J-Y-R).
FIUBA
31
(Método estático)
Arbol final para la fuente JERRYRICE
Codificación: C=010, E=00, I=011, J=100, R=11, Y=101
Representación final: 100-00-11-11-101-11-011-010-00
●22 bits de longitud contra 21.74 dados por la entropía
●Notar que la cantidad de bits es entera!!!
FIUBA
32
(método estático)
La emisión debe incluir la tabla de frecuencias,
debido que es necesaria para la descompresión.
●
●
●
Tabla: C = 1, E = 2, I = 1, J = 1, R = 3, Y = 1
Análisis de la compresión
FIUBA
33
(método estático)
En primer lugar cabe aclarar que el descompresor
debe armar EL MISMO árbol que el compresor.
Para esto se siguen los siguientes pasos:
● El descompresor lee la tabla de frecuencias,
generando el mismo árbol(pensar que el algoritmo
es el mismo)
●Finalmente lo que se hace, con el arbol armado,
es leer bit a bit el archivo que tenemos y emitir
cuando lleguemos a un nodo hoja.
●
FIUBA
34
(método estático)
Descompresión de la fuente JERRYRICE
● Se lee la tabla de frecuencias y se arma el mismo
árbol final(0 a izq, 1 a derecha ):
Se lee bit a bit y se mueve sobre las ramas del
árbol emitiendose cuando se llega a un hoja
obteniendose la siguiente tabla:
●
FIUBA
35
(método estático)
Descompresión de la fuente JERRYRICE(Cont.)
Paso
0 1
2 3
4
5
6
7
8
9 10 11 12 13 14 15 16 17 18 19 20 21
Bit Leido
1 0
0 0
0
1
1
1
1
1 0
1
1
1 0
1
1 0
1
0 0
0
Mov. En Arbol Der. Izq Izq. Izq Izq. Der. Der. Der. Der. Der. Izq Der. Der. Der. Izq Der. Der. Izq Der. Izq. Izq Izq.
T.Nodo
Int. Int. Hoj. Int. Hoj. Int. Hoj. Int. Hoj. Int. Int. Hoj. Int. Hoj. Int. Int. Hoj. Int. Int. Hoj. Int. Hoj.
Emisión
FIUBA
---- ---- J
---- E
---- R
---- R
---- ---- Y
---- R
---- ---- I
---- ---- C
---- E
36
(método dinámico)
Todas las frecuencias se asumen
inicialmente iguales a 1
●Se construye el árbol completo en cada
paso para la tabla de frecuencias actual
●En la siguiente diapositiva se muestra el
árbol final antes de cada emisión, no la
construcción paso a paso.
●
FIUBA
37
(método dinámico)
Emisión: 111-101-110-01-110-10-011-010-101
25 bits (3 más que el estático)
FIUBA
38
(método dinámico)
La emisión no incluye la tabla de
frecuencias
●El compresor y el descompresor conocen
implícitamente el alfabeto (por ejemplo, los
bytes del 0 a 255), no hace falta
transmitirlo
●Para emitir bytes completos, se usan las
mismas técnicas vistas para finalizar
archivos
●
FIUBA
39
(método dinámico)
●
Descompresión:
●
●
●
FIUBA
Sigue la misma idea que el estático, salvo que la
tabla de frecuencias arrancan para todos los
caracteres en 1.
Se lee el archivo bit a bit, moviéndonos en el árbol
hasta llegar a un nodo hoja. Es en este momento
donde emitimos el carácter correspondiente.
A diferencia del anterior, debemos incrementar la
frecuencia de dicho carácter(siempre siguiendo la
misma lógica que en el compresor)
40
(método dinámico)(Cont.)
Tabla Ejemplo Descompresión JERRYRICE:
●
Paso
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
Bit Leido
1
1
1
1
0
1
1
1
0
0
1
1
1
0
1
0
0
1
1
0
1
0
1
0
1
Mov. En Arbol
Izq.
Izq.
Izq.
Izq.
Der.
Izq.
Izq.
Izq.
Der.
Der.
Izq.
Izq.
Izq.
Der.
Izq.
Der.
Der.
Izq.
Izq.
Der.
Izq.
Der.
Izq.
Der.
Izq.
T.Nodo
Int.
Int.
Hoj.
Int.
Int.
Hoj.
Int.
Int.
Hoj.
Int.
Hoj.
Int.
Int.
Hoj.
Int.
Hoj.
Int.
Int.
Hoj.
Int.
Int.
Hoj.
Int.
Int.
Hoj.
Emisión
----
----
J
----
----
E
----
----
R
----
R
----
----
Y
----
R
----
----
I
----
----
C
----
----
E
Actualización
Tabla
----
----
J(2)
----
----
E(2)
----
----
R(2)
----
R(3)
----
----
Y(2)
----
R(3)
----
----
I(2)
----
----
C(2)
----
----
E(3)
FIUBA
41
(método dinámico)
●
Descompresión(Cont.):
●
FIUBA
Arboles finales generados en cada paso de la
tabla:
42
Manejo Eficiente
(método dinámico)
Logra una actualización rápida del árbol
de un paso al otro
●No cambia el nivel de compresión
●Los nodos tienen 2 hijos o ninguno
●Para tener un árbol óptimo alcanza con
que:
●
Si
P(A) > P(B) entonces L(A) ≤ L(B)
Si
P(A) = P(B) entonces |L(A)-L(B)| ≤ 1
Regla
FIUBA
de oro: Si #A > #B => F(A) ≤ F (B)
43
Manejo Eficiente
(método dinámico)
Se numeran (#) los nodos en forma
ascendiente, de la raíz hacia abajo y de
derecha a izquierda, y se escribe la
frecuencia total del nodo (Ej: C anterior)
●
FIUBA
44
Huffman dinámico:
manejo eficiente
Si aumenta en 1 la frecuencia de la Y, la
estructura del árbol no necesita cambiar
porque la frecuencia aumenta de izq a der,
de abajo a arriba:
●
FIUBA
45
Manejo Eficiente
(método dinámico)
Si en vez de eso aumenta en 1 la
frecuencia de la E, la estructura del árbol
cambia: se intercambia el nodo de la E
(nodo 10) y el nodo de menor numeración
con frecuencia superior (nodo 7):
●
FIUBA
46
Manejo Eficiente
(método dinámico)
Caso particular: al aumentar la frecuencia
de C en este árbol(hoja- no hoja)
●
El nodo candidato para el intercambio es
el 3. Se realiza el intercambio y el árbol
queda..
FIUBA
47
Manejo Eficiente
(método dinámico)
Notar que se intercambio el sub-árbol
entero del nodo 3.
●Este árbol sigue siendo un árbol de
Huffman ya que cumple con todas las
propiedades
●
FIUBA
48
Manejo Eficiente
(método dinámico)
●
Ejemplo de compresión(fte: porotosEOF)
●
Arbol inicial(vocabulario o,p,r,s,t,EOF):
FIUBA
49
Manejo Eficiente
(método dinámico)
●
1) Arbol Inicial
2)Lectura p(Emisión 10)
3) Lectura o(Emision 11)
4)Lectura r(Emisión 011)
FIUBA
50
Manejo Eficiente
(método dinámico)
●
6)Lectura t(Emisión 001)
8)Lectura s(Emisión 110)
FIUBA
51
Manejo Eficiente
(método dinámico)
●
9) Lectura EOF(Emision 101)
●
●
●
FIUBA
Notar que se emite con el arbol de la figura anterior a la lectura.
En el ultimo paso no es neceseario actualizar el arbol.
Emision final(sin guiones): 10-11-011-11-001-01-110= 20 bits= 2,5 bytes.
52
Manejo Eficiente
(método dinámico)
●
Ejemplo de descompresión(fte: porotosEOF)
●
Arbol inicial(vocabulario o,p,r,s,t,EOF):
FIUBA
53
Manejo Eficiente
(método dinámico)
●
FIUBA
●
El método es similar a la descompresión explicada anteriormente.
●
1) Se lee bit 1, luego bit 0 -> se emite p-> se actualiza el arbol.
●
2) Se lee bit 1, luego bit 1 -> se emite o-> se actualiza el arbol.
54
Manejo Eficiente
(método dinámico)
●
FIUBA
●
●
3) Se lee bit 0, luego bit 1 y bit 1 -> se emite r-> se actualiza el arbol.
●
55
Manejo Eficiente
(método dinámico)
●
FIUBA
●
●
5) Se lee bit 0, luego bit 0 y bit 1 -> se emite t-> se actualiza el arbol.
●
56
Manejo Eficiente
(método dinámico)
●
FIUBA
●
●
7) Se lee bit 1, luego bit 1 y bit 0 -> se emite s-> se actualiza el arbol.
●
8) Se lee bit 1, luego bit 0 y bit 1 -> se emite EOF
57
Referencias
●
FIUBA
D.A. Huffman, "A Method for the Construction of
Minimum-Redundancy Codes", Proceedings of
the I.R.E., September 1952, pp 1098–1102.
Huffman's original article.
58
Algoritmo de Aritmético
(Estadístico)
FIUBA
59
(Estadístico)
Segmento de generación de códigos.
●
Genera un único código, que representa a todo el archivo, longitud
variable.
●
Ese código aproxima a las longitudes calculadas por el Teorema
de Shannon en fracciones bits.
●
No asigna a cada símbolo un código en bits de longitud entera. Se
puede decir que cada símbolo está representado por un código de
longitud no entera de bits, formando parte del código único.
●
FIUBA
60
(Estadístico)
Segmento de generación de códigos(Cont.)
●
Utiliza un segmento dividido en función de las probabilidades de
los caracteres a considerar para generar las emisiones.
●
El camino de decisiones tomadas, segmento a segmento, genera
emisiones de números binarios que se concatenan y dan como
resultado el archivo comprimido.
●
Conceptualmente codifica el archivo entero como un número real
de 0 a 1
●
FIUBA
61
(Estadístico)
Segmento Aritmético
●
●
Ej: AAABBCC
Se divide el intervalo de “0 a 1” según la probabilidad de los símbolos (se
adapta al intervalo con el que se está comprimiento. Ej: 0 – 255)
●
FIUBA
●
En cada paso se elige un subintervalo según el símbolo leído
●
En el siguiente paso se divide el subintervalo elegido de la misma forma
●
Se repite hasta llegar al último carácter
●
Finalmente se emite un número del subintervalo elegido en el último paso
62
(Estadístico)
Soluciones técnicas para las limitaciones del
hardware (Overflow y Underflow):
●
Las computadoras no trabajan nativamente con números reales de
precisión arbitraria.
●
En vez de utilizar un intervalo real para trabajar, se elige un
intervalo entero de 0 a 2N. Los números de ese intervalo tendrán N
bits de precisión
●
FIUBA
63
(Estadístico)
División de un intervalo:
●
Se divide el intervalo [Piso1,
TechoN] en N subintervalos de
diversas longitudes
●Sea L = Techo
N - Piso1 + 1
●Techo = floor(Piso + P(s ).L) - 1
i
i
i
●Piso
i+1 = Techoi + 1
●
En el siguiente paso, el
subintervalo elegido es el
que se subdivide
●
FIUBA
64
(Estadístico)
Overflow:
●
Situación en la que se permite dejar
de considerar el bit más significativo
de los límites del intervalo, dado que
ese valor pertenece con seguridad al
código final generado.
1101
1011
●
Emito el '1' y completo.
1000
FIUBA
0000
65
(Estadístico)
Underflow:
●
Situación en la que se pierde
presición porque en el proceso de
compresión se llegó a una situación
donde la diferencia entre el techo y el
piso es inferior a la unidad del bit más
significativo y de su siguiente, por lo
que solo podrán cambiar los restantes
en los pasos que continúan. Esto
puede llevar a que se congelen más
bits, al punto de no poder avanzar por
tener congelados a todos.
1010
1101
●
FIUBA
UF=0
UF=1
Sumo '1' al contador
De Underflow,
Quito el segundo Bit
y completo.
0110
0100
66
(Estadístico)
Es posible que tras normalizar un overflow,
se descubra un underflow
●
Techo:
Piso:
FIUBA
11011001  11100111
10101110  00111000 (U=1)
67
(Estadístico)
Al detectar un overflow y realizar la emisión, se emiten
tras el primer dígito tantos dígitos negados como sea el
contador de underflow y se pone el contador en 0
(U=2)
Techo:
11101101 
11101111
Piso:
11010110 
00110000
●
Emisión: 1-00-1, nuevo valor de U=1
FIUBA
68
(Estadístico)
Cuanto más chico es el intervalo, más precisión hace
falta para representarlo.
●Cuanto más probable es un símbolo, más grande su
intervalo y menos bits se emiten cuando ocurre.
●El método estático emite (guarda) la tabla de
frecuencias y requiere dos pasadas.
●El método dinámico no guarda la tabla de frecuencias,
pero comprime generalmente menos que el estático.
●
FIUBA
69
(método estático)
Se genera la tabla de frecuencias con la primer
pasada.
●Se divide el intervalo de "0 a 1" según la probabilidad
dada por la tabla de frecuencias (que es estática).
●En cada paso se elige un subintervalo según el símbolo
leído.
●Se repite hasta llegar al último carácter
●
FIUBA
70
(método estático)
Finalmente se emite un número del subintervalo
elegido en el último paso (por convención, el piso)
●El código resultante es el mejor que puede generar
este compresor.
●Define el fin de archivo con la suma de frecuencias de
los caracteres, que es igual a las emisiones totales.
●
FIUBA
71
(método estático)
●
Compresión de BAABCA:
Compresión del caracter 'B' - (Posicion: 0)
●
Piso inicial: 0 - Techo Inicial 255 Intervalo: 256
N.Piso = 0 + 256 * 3 / 6 = 128 N. Techo = 0 + 256 * 5 / 6 - 1 = 212
Resultado de la normalización:
Piso: 10000000 (128) -> 00000000 (0) Techo: 11010100 (212) -> 10101001 (169)
Emisión: 1
C. underflow: 0
Compresión del caracter ‘A' - (Posicion: 1)
●
N.Piso = 0 + 170 * 0 / 6 = 0 N. Techo = 0 + 170 * 3 / 6 - 1 = 84
Piso 00000000 (0) -> 00000000 (0) Techo: 01010100 (84) -> 10101001 (169)
Emisión: 0
C. underflow: 0
FIUBA
72
(método estático)
●
●
N.Piso = 0 + 170 * 0 / 6 = 0 N. Techo = 0 + 170 * 3 / 6 - 1 = 84
Piso: 00000000 (0) -> 00000000 (0) Techo: 01010100 (84) -> 10101001 (169)
Emisión: 0
C. underflow: 0
Compresión del caracter ‘B' - (Posicion: 3)
●
N.Piso = 0 + 170 * 3 / 6 = 85 N. Techo = 0 + 170 * 5 / 6 - 1 = 140
Piso: 01010101 (85) -> 00101010 (42) Techo: 10001100 (140) -> 10011001 (153)
Emisión:
C. underflow: 1
FIUBA
73
(método estático)
●
Compresión del caracter ‘C' - (Posicion: 4)
●
N.Piso = 42 + 112 * 5 / 6 = 135 N. Techo = 42 + 112 * 6 / 6 - 1 = 153
Piso: 10000111 (135) -> 00111000 (56) Techo: 10011001 (153) -> 11001111 (207)
Emisión: 1000(Underflow)
C. underflow: 0
●
N.Piso = 56 + 152 * 0 / 6 = 56 N. Techo = 56 + 152 * 3 / 6 - 1 = 131
Al ser el ultimo caracter, se emite el piso, incluyendo los underflows: Piso: 00111000 (56) --- > Emisión: 00111000
Emision final:1-0-0-1000-00111000
FIUBA
74
(método estático)
●
Descompresión de BAABCA:
Archivo comprimido: 100100000111000
●Se leen la tablas de frecuencias(que están en el mismo
archivo):
●
A= 3, B=2, C=1
●
Se plantea el intervalo inicial y se leen de a N bits(N
precisión del compresor/descompresor)
●
FIUBA
75
(método estático)
●
Descompresión del caracter 'B‘
●
●
Rangos iniciales:
●
C = [213 - 255] = [11010101 - 11111111]; B = [128 - 212] = [10000000 - 11010100] ; A = [000 - 127] = [00000000 - 01111111]
●
Se leen 8 bits: 10010000 -> Cae en el rango de la B(128-212)
Se emite una B.
●
Descompresión del caracter ‘A'
●
Se plantea el nuevo intervalo(128-212)(Overflow de 1)
Resultado de la normalización(Overflow de 1):
Piso: 10000000 (128) -> 00000000 (0) Techo: 11010100 (212) -> 10101001 (169)
Nuevos Intervalos:
C [141 - 169] = [10001101 - 10101001] ; B [085 - 140] = [01010101 - 10001100] ; A [000 - 084] = [00000000 - 01010100]
Debido al overflow, descartamos el 1er bit leído anteriormente y leemos uno mas del archivo: 100100000
00100000 -> Cae en el rango de la A
Se emite una A.
FIUBA
76
(método estático)
●
Descompresión del caracter ‘A‘
●
Piso 00000000 (0) -> 00000000 (0) Techo: 01010100 (84) -> 10101001 (169)
C [141 - 169] = [10001101 a 10101001] ; B [085 - 140] = [01010101 - 10001100] ; A [000 - 084] = [00000000 - 01010100]
Se emite una A.
Descompresión del caracter ‘B‘
●
Piso 00000000 (0) -> 00000000 (0) Techo: 01010100 (84) -> 10101001 (169)
Nuevos Intervalos:
C [141 - 169] = [10001101 - 10101001] ; B [085 - 140] = [01010101 - 10001100] ; A [000 - 084] = [00000000 - 01010100]
01000001 -> Cae en el rango de la B
Se emite una B.
FIUBA
77
(método estático)
●
Descompresión del caracter ‘C‘
●
Se plantea el nuevo intervalo(85-140)(Underflow -> Cont. UF=1)
Resultado de la normalización(Underflow de 1):
Piso: 01010101 (85) -> 00101010 (42) Techo: 10001100 (140) -> 10011001 (153)
Nuevos Intervalos:
C [135 - 153] = [10000111 - 10011001] ; B [098 - 134] = [01100010 - 10000110] ; A [042 - 097] = [00101010 - 01100001]
Debido al Underflow, dejamos fijo el 1er bit en inspección y luego descartar tantos bits como underflows tengamos(1 bit en este caso, 0),
completar del archivo leyendo los bits necesarios para 1 byte :
10000111 -> Cae en el rango de la C
1001(Fijo)0(Descartado)0000111(leído)
Se emite una C.
●
Piso: 10000111 (135) -> 00111000 (56) Techo: 10011001 (153) -> 11001111 (207)
Nuevos Intervalos:
C [182 - 207] = [10110110 - 11001111] ; B [132 - 181] = [10000100 - 10110101] ; A [056 - 131] = [00111000 - 10000011]
Debido al overflow, descartamos los 3 1eros bits leídos anteriormente y leemos 3 mas del archivo: 1001(O)000(O)00111000(Leidos)
Se emite una A. Además es el piso del intervalo y sabemos que teniamos 6 caracteres-> Fin.
FIUBA
78
(método dinámico)
Se asigna frecuencia 1 a todos los símbolos
●Se divide el intervalo de "0 a 1" según la probabilidad
dada por la tabla de frecuencias
●En cada paso se elige un subintervalo según el símbolo
leído. Luego se modifica la tabla de frecuencias
●En el siguiente paso se divide el subintervalo elegido
según la nueva tabla
●Se repite hasta llegar al último carácter
●
FIUBA
79
(método dinámico)
Finalmente se emite un número del subintervalo
elegido en el último paso
●Las probabilidades se van modificando, adecuando, a
medida que se avanza en la compresión.
●El código resultante es igual o peor que el generado
por el estático (pero no necesita tabla de frecuencias).
●El fin de archivo, generalmente, se define con un
caracter especial (EOF). También se pueden indicar la
cantidad de emisiones al principio del archivo.
●
FIUBA
80
(Dinamico)
●
Compresión de ABAC:
●
A=1, B=1, C=1  A=2, B=1, C=1
N.Piso = 0 + 256 * 0 = 0 N. Techo = 0 + 256 * 1 / 3 - 1 = 84
Piso: 00000000 (0) -> 00000000 (0) Techo: 01010100 (84) -> 10101001 (169)
Emisión: 0
C. underflow: 0
●
A=2, B=1, C=1  A=2, B=2, C=1
N.Piso = 0 + 170 * 2 / 4 = 85 N. Techo = 0 + 170 * 3 / 4 - 1 = 126
Piso 01010101 (85) -> 01111110 (126) Techo: 01010100 (84) -> 11111011 (251)
Emisión: 01
C. underflow: 0
FIUBA
81
(Dinamico)
●
Compresión de ABAC :
●
A=2, B=2, C=1  A=3, B=2, C=1
N.Piso = 84 + 168 * 0 / 5 = 84 N. Techo = 84 + 168 * 2 / 5 - 1 = 150
Piso: 01010100 (84) -> 00101000 (40) Techo: 10010110 (150) -> 10101101 (173)
Emisión: -
C. underflow: 1
●
A=3, B=2, C=1  A=3, B=2, C=2
N.Piso = 40 + 134 * 5 / 6 = 151 N. Techo = 40 + 134 * 6 / 6 - 1 = 173
Emision final: 0-01-100010111
FIUBA
82
(Dinamico)
●
Descompresión de ABAC:
●
A=1, B=1, C=1  A=2, B=1, C=1
●
Rangos iniciales:
●
C = [170 - 255] = [10101010 - 11111111]; B = [85 - 169] = [001010101 - 10101001] ; A = [0 - 84] = [00000000 - 001010100]
●
Se leen 8 bits: 00110001 (25) -> Cae en el rango de la A(0-84)
Se emite una A.
●
●
A=2, B=1, C=1  A=2, B=2, C=1
Piso: 00000000 (0) -> 00000000 (0) Techo: 01010100 (84) -> 10101001 (169)
Nuevos Intervalos:
C [127 - 169] = [01111111 - 10101001] ; B [85 - 126] = [01010101 - 01111110] ; A [0 - 84] = [00000000 - 01010100]
01100010 (98) -> Cae en el rango de la B
Se emite una B.
FIUBA
83
(Dinamico)
●
Descompresión de ABAC:
●
A=2, B=2, C=1  A=3, B=2, C=1
Piso 01010101 (85) -> 01010100 (84) Techo: 01111110 (126) -> 11111011 (251)
C [218 - 251]; B [151 - 217]; A [84 - 150]
Debido al overflow, descartamos los dos primeros bits leídos anteriormente y leemos dos mas del archivo:
10001011 (139) -> Cae en el rango de la A
00110001011(leídos)
Se emite una A.
●
A=3, B=2, C=1  A=3, B=2, C=2
Se plantea el nuevo intervalo(84-150)(Underflow de 1)
Piso 01010100 (84) -> 00101000 (40) Techo: 10010110 (150) -> 10101101 (173)
Nuevos Intervalos:
C [151 – 173] ; B [107 - 150] ; A [40 - 106]
0011(Fijo)0(Descartado)0010111(leídos)
10010111 (151) -> Cae en el rango (es el piso) de la C
Se emite una C.
FIUBA
84
Referencias
●
FIUBA
Witten, Ian H.; Neal, Radford M.; Cleary, John G.
(June 1987). "Arithmetic Coding for Data
Compression" (PDF). Communications of the
ACM 30 (6): 520–540. Retrieved 2007-09-21.
85
Algoritmos de
Compresión No
estadística
Algoritmo Lz77
Algoritmo Lz78/W
FIUBA
86
Algoritmos de Compresión
Run Length
●
●
●
FIUBA
Detecta repeticiones de símbolos y las reemplaza
por pares (símbolo,longitud)
Funciona bien cuando hay secuencias de
símbolos que se repiten mucho
Se suelen implementar como parte de algoritmos
mas complejos
87
Run Length
Ejemplos:
ABCABCABC
1A1B1C1A1B1C1A1B1C
AAABBBCCC
3A3B3C
●
FIUBA
Estadístico: Mal
Run length.: Mal
Estadístico: Igual de mal
Run Length.: Bien!
Notar que aumenta el tamaño si no se repiten los
caracteres
88
Algoritmos de Compresión por
Diccionario
●
●
Consisten en sustituir una cadena de varios
símbolos por un puntero a la entrada en un
diccionario, el cual puede ser estático o adaptable
(dinámico)
Un mismo símbolo no siempre se sustituye con lo
mismo (≠ codificación)
“Esto es una clase de
organización de datos. Cátedra
servetto”
233/4 219/5 579/2 121/9 182/1
393/7 182/1 180/1 99/15
servetto
FIUBA
89
Algoritmo Lz77
(por Diccionario)
●
Abraham Lempel y Jacob Ziv en 1977
●
Es la base del formato gráfico PNG(B&N)
●
El diccionario es la ventana de memoria
(adaptativo)
Ventana de Memoria
(Memory Window)
Tamaño M
Ventana de Inspección
(Lookahead Window)
Tamaño N
Input
Logitud Mínima de Match (A)
FIUBA
90
Algoritmo Lz77
(por Diccionario)
●
Siempre nos quedamos con el acierto más grande y en caso de haber un
acierto de la misma longitud, nos quedamos con el de menor posición.
●
Un bit más para distinguir la codificación de un par ordenado de un carácter.
●
Para codificar posiciones y longitudes:
●
●
●
FIUBA
P posiciones posibles (0,..,P): K bits -> K = Techo(Log2 (M – A + 1))
L longitudes posibles (A,…,L): K2 bits ->K2 = Techo(Log2 (Min(M,N)–
A+1))
+ 1 bit de diferencia entre carácter y dupla = (K+K2+1) bits por emisión
91
Algoritmo Lz77
(por Diccionario)
●
●
●
Método de Compresión :
Inicialmente se toma la ventana de memoria como vacía (con algún caracter especial para indicar ello por
ejemplo) y se carga la ventana de inspección con los primeros N caracteres del archivo
Mientras sigan quedando caracteres en la ventana de inspección (mientras no se haya llegado al fin del archivo)
se compara el string que comienza en la posición 0 de dicha ventana con todos los strings que comienzan en
cada posición de la ventana de memoria.
●
•
FIUBA
Si no hay ningún match de longitud mayor a la mínima, entonces se emite el primer caracter de la ventana de inspección
y ambas ventanas se desplazan 1 caracter (la ventana de memoria pierde su primer caracter y el ultimo pasa a ser el
caracter recientemente comprimido; la ventana de inspección también pierde su primer caracter y lee del archivo a
comprimir el siguiente caracter, que ubica al final)
Si hay al menos un match de longitud mayor a la mínima, se toma el match de mayor longitud (puede haber varios
matchs) y se emite primero la posición en la que se dio el match en la ventana de memoria y luego la longitud del
mismo. Las dos ventanas se desplazan tantos caracteres como sea la longitud de dicho match (la de memoria pierde
sus primeros k caracteres y los k últimos pasan a ser el substring que matcheo, la de inspección también pierde sus
primeros k caracteres y lee otros k del archivo que los ubica al final). En caso de empate entre 2 matchs con la longitud
máxima se debe tomar alguna convención, por ejemplo emitir la de menor posición
92
Algoritmo Lz77
(por Diccionario)
●
Ejemplo de Compresión fuente
RAPATAPATAPARAPAPA :
●
●
●
Tamaño Ventana de Memoria = 6
Tamaño Ventana de Inspección= 5
Tamaño mínimo match = 2
●
●
●
FIUBA
Longitudes posibles= L2,L3,L4,L5
● Techo(Log2 (Min(M,N)–A+1)) = Techo(log2(4))=2bits
Posiciones posibles= 0,1,2,3,4(P5 no se puede dar)
● Techo(Log2 (M – A + 1))= Techo(log2(5))=3 bits
Par (posicion,longitud) = 6 bits y carácter 9 bits.
93
Algoritmo Lz77
(por Diccionario)
●
Ventana de Memoria(6) Ventana de Inspeccion(5) Salida del Compresor
FIUBA
Ubicaciones de las ventanas en file
------
RAPAT
R
|RAPAT|APATAPARAPAPA
-----R
APATA
A
|R|APATA|PATAPARAPAPA
----RA
PATAP
P
|RA|PATAP|ATAPARAPAPA
---RAP
ATAPA
A
|RAP|ATAPA|TAPARAPAPA
--RAPA
TAPAT
T
|RAPA|TAPAT|APARAPAPA
-RAPAT
APATA
(P2-L4)
|RAPAT|APATA|PARAPAPA
ATAPAT
APARA
(P2-L3)
RAP|ATAPAT|APARA|PAPA
PATAPA
RAPAP
R
RAPATA|PATAPA|RAPAP|A
ATAPAR
APAPA
(P2-L3)
RAPATAP|ATAPAR|APAPA|
PARAPA
PA---
(P0-L2)
RAPATAPATA|PARAPA|PA|
94
Algoritmo Lz77
(por Diccionario)
●
●
6 caracteres * 9 bits = 54 bits
R
A
P
A
T
(P2-L4)
4 pares(pos,long) * 6 bits= 24 bits
(P2-L3)
●
Total: 78 bits= 9,75 bytes.
(P2-L3)
●
Tam. Original: 18 caracteres => 18 bytes
●
●
FIUBA
R
(P0-L2)
Tasa Compresión= 9,75 bytes/18 bytes* 100% = 54,16%
95
Algoritmo Lz77
(por Diccionario)
●
Descompresión:
●
●
El descompresor tiene la misma configuracion que el
compresor.
La idea de la descompresión es leer primero un
bit(para saber cuantos leer luego).
●
Considerando que un 0 es un caracter y 1 (pos,long)
●
●
FIUBA
Si ese bit es 0 -> leemos 8 bits mas.
Si ese bit es 1 -> leemos 5 bit mas.
96
Algoritmo Lz77
(por Diccionario)
●
Ejemplo de Descompresión fuente
Ventana de Memoria(6)
----------R
----RA
---RAP
--RAPA
-RAPAT
ATAPAT
PATAPA
ATAPAR
PARAPA
FIUBA
Lectura del archivo comprimido
R
A
P
A
T
(P2-L4)
(P2-L3)
R
(P2-L3)
(P0-L2)
Salida del Descompresor
R
A
P
A
T
APAT
APA
R
APA
PA
97
Referencias
●
FIUBA
Jacob Ziv and Abraham Lempel; A Universal
Algorithm for Sequential Data Compression,
IEEE Transactions on Information Theory, 23(3),
pp. 337–343, May 1977.
98
Algoritmo Lz78/W
(por Diccionario)
Abraham Lempel y Jacob Ziv en 1978
●También utiliza un diccionario adaptativo, pero de todos los símbolos anteriores
●
La cantidad de bits emitidos dependen del tamaño de la tabla
●Original: 11 letras x 8 bits = 88 bits
●Comprimido: 1 código x 8 bits + 6 códigos x 9 bits = 62 bits
●
FIUBA
99
Algoritmo Lz78/W
(por Diccionario)
Descompresión
●
–El tamaño de la tabla indica la cantidad de bits que tengo que leer
–Se empieza con el diccionario vacío y se va regenerando
–Siempre se almacena lo anterior más la primera letra del próximo
Caso Especial
●
–Cuando para agregar una entrada en la tabla tengo que leer un símbolo que no tengo
¿Cómo lleno este
símbolo? LA (256) + L
(primera letra del símbolo
actual)
FIUBA
100
Algoritmo Lz78/W
(por Diccionario)
●
Ejemplo Compresión (Fte: TETETERARA)
Ubicación en el archivo String actual
TETETERARA T
ETETERARA TE
ETETERARA E
TETERARA ET
TETERARA T
ETERARA TE
TERARA TET
TERARA T
ERARA TE
RARA TER
RARA R
ARA RA
ARA A
RA AR
RA R
A RA
fin
FIUBA
¿Esta en Tabla?
SI
NO
SI
NO
SI
SI
NO
SI
SI
NO
SI
NO
SI
NO
SI
SI
Codigo Emitido
----T
----E
--------256
--------256
----R
----A
--------260
Actualizacion de Tablas
----256-TE
----257-ET
--------258-TET
--------259-TER
----260-RA
----261-AR
------------101
Algoritmo Lz78/W
(por Diccionario)
Ejemplo de descompresion (Fc = T-E-256-258-E-R-A-262-A)
Archivo original: F=TETETETERAAAA
●
●
Ubicación en el archivo
String actual
¿Esta en Tabla?
Codigo Emitido
Actualizacion de Tablas
T-E-256-258-E-R-A-262-A
T
SI
T
-----
E-256-258-E-R-A-262-A
E
SI
E
256-TE
256-258-E-R-A-262-A
256
SI
TE
257-ET
258-TE* (lo emitido en el paso
anterior + primer carácter de
emisión actual)
FIUBA
Primer caracter = T
258-E-R-A-262-A
258
NO (caso
especial)
E-R-A-262-A
E
SI
E
259-TETE
R-A-262-A
R
SI
R
260-ER
A-262-A
A
SI
A
261-RA
262-A
262
NO
A*  AA
262-A*  262-AA
A
A
SI
A
263-AAA
TE*  TET
258-TET
102
Algoritmo Lz78/W
(por Diccionario)
La tabla crece a medida que avanza la compresión y
aumenta la complejidad de las búsquedas y
comparaciones.
● El diccionario puede implementarse como un árbol para
acelerar las búsquedas.
● Clearing: Para evitar que la tabla crezca indefinidamente
(ya no gano demasiado en compresión) puedo:
●
Dejar de agregar cosas al diccionario
●
Limpiar la tabla (usando un carácter especial que simbolice
limpieza de tabla o no).
●
Usar técnicas de reemplazo de entradas (Ej: LRU)
●
FIUBA
103
Referencias
●
FIUBA
Terry Welch, "A Technique for High-Performance
Data Compression", IEEE Computer, June 1984,
p. 8–19.
104
Algoritmos de
Compresión
Predictores
Algoritmo Aritmético de Orden mayor a 1
Algoritmo PPMC
FIUBA
105
Predictores
●
●
●
●
FIUBA
Utilizan estructuras de datos para registrar pasos anteriores de la
compresión.
Se parte de una concepción estadística, que reconoce como
altamente probable la aplicación de la misma acción ante una
misma situación (eso es el acierto predictor).
Se basa en algoritmos estadísticos clásicos, pero modifican la
forma de calcular la probabilidad de las apariciones,
considerando probabilidades condicionales (Contextos).
Funciona bien cuando se cumple la regla de la concepción
estadística situación-acción.
106
Predictores
●
Contextos:
●
Se parte de la base de que un texto tiene secuencias que se
repiten.
–
●
●
●
FIUBA
Ej: En un programa escrito en C, luego del carácter “;” es altamente
probable un fin de línea.
Para cada carácter, el o los caracteres precedentes son su
contexto.
El orden de un contexto es la cantidad de caracteres
precedentes que se toman en cuenta para predecir. Orden 0
(“O(0)”) significa ningún carácter. Orden 1 (“O(1)”), un carácter.
Aumentan considerablemente el consumo de memoria por la
gran cantidad de datos que deben registrar.
107
Algoritmo Aritmético O(n)
(Predictor)
FIUBA
108
Algoritmos Aritmético O(n)
(Predictor)
●
Es una generalización del Algoritmo Aritmético de compresión.
●
Separa las estructuras de Emisión y de Distribución de probabilidades.
Para cada caracter (o cadena) se almacena una tabla de probabilidades
asociada, para considerar a todos los caracteres que le pueden seguir.
●
Dado el
Contexto
1
A
Dado el
Contexto
2
A
-
-
FIUBA
B
B
C
C
Dado el
Contexto
3
Segmento de
emisión
1111
0101
1011
A
B
-
Emito '0'
C
0000
0001
0010
109
Predictores
●
Ventajas de utilizar contextos
• Utilizar distintas tablas de probabilidades según el
contexto ayuda a predecir mejor
• Una mejor predicción equivale a mejores modelos
probabilísticos
• Mejores modelos equivalen a una menor emisión en
bits.
FIUBA
110
Predictores
●
Desventajas de utilizar
contextos
• O (0) necesita una tabla de 256
posiciones(una para cada
carácter)
• O (1) necesita una tabla de
256x256 posiciones. O (2), una
tabla de 256x256x256.
• El tamaño de las tablas crece
exponencialmente.
• Si la fuente no tiene patrones
repetidos (no es estructurada),
utilizar contextos no mejora la
compresión
FIUBA
A
B
C
D
..
A
B
C
D
..
A
B
C
..
A
B
A
B
C
D
..
C
..
A
B
C
D
..
A
B
C
..
111
(Orden 1)
●
Compresión de ABACAB:
●
Contexto \b: A=1, B=1, C=1
N.Piso = 0 + 256 * 0 = 0 N. Techo = 0 + 256 * 1 / 3 - 1 = 84
Piso: 00000000 (0) -> 00000000 (0) Techo: 01010100 (84) -> 10101001 (169)
Emisión: 0
C. underflow: 0
●
Contexto A: A=1, B=1, C=1  Contexto A: A=1, B=2, C=1
N.Piso = 0 + 170 * 1 / 3 = 56 N. Techo = 0 + 170 * 2 / 3 - 1 = 112
Piso 00111000 (56) -> 01110000 (112) Techo: 01110000 (112) -> 11100001 (225)
Emisión: 0
C. underflow: 0
FIUBA
112
(Orden 1)
●
Compresión de ABACAB :
●
Contexto B: A=1, B=1, C=1  Contexto B: A=2, B=1, C=1
N.Piso = 112 + 114 * 0 / 3 = 112 N. Techo = 112 + 114 * 1 / 3 - 1 = 149
Piso: 01110000 (112) -> 01000000 (64) Techo: 10010101 (149) -> 11010111 (215)
Emisión: 0
C. underflow: 2
●
N.Piso = 64 + 152 * 3 / 4 = 178 N. Techo = 64 + 152 * 4 / 4 - 1 = 215
Piso: 10110010 (178) -> 01001000 (72) Techo: 11010111 (215) -> 11011111 (223)
C. underflow: 1
FIUBA
113
(Orden 1)
●
Compresión de ABACAB:
●
Contexto C: A=1, B=1, C=1  Contexto C: A=2, B=1, C=1
N.Piso = 72 + 152 * 0 / 3 = 72 N. Techo = 72 + 152 * 1 / 3 - 1 = 121
Piso: 01001000 (72) -> 00100000 (32) Techo: 01111001 (121) -> 11100111 (231)
C. underflow: 0
●
N.Piso = 32 + 200 * 1 / 5 = 72 N. Techo = 32 + 200 * 3 / 5 - 1 = 151
Emision final:0-0-100-011-01001000
FIUBA
114
(Orden 1)
●
Descompresión de ABACAB:
●
Contexto \b: A=1, B=1, C=1
●
Rangos iniciales:
●
C = [170 – 255]; B = [85 - 169] ; A = [0 – 84]
●
Se leen 8 bits: 0010001 (32) -> Cae en el rango de la A(0-84)
Se emite una A.
●
●
Piso: 00000000 (0) -> 00000000 (0) Techo: 01010100 (84) -> 10101001 (169)
Nuevos Intervalos:
C [113 – 169]; B [55 – 112] ; A [000 - 55]
01000111 (71) -> Cae en el rango de la B
Se emite una B.
FIUBA
115
(Orden 1)
●
●
Contexto B: A=1, B=1, C=1  Contexto B: A=2, B=1, C=1
Piso 00111000 (56) -> 01110000 (112) Techo: 01110000 (112) -> 11100001 (225)
C [188 - 225]; B [150 - 187]; A [112 - 149] = [01110000 - 10010101]
Se emite una A.
●
Se plantea el nuevo intervalo(112-149)(Underflow de 2)
Piso 01110000 (112) -> 01000000 (64) Techo: 10010101 (149) -> 110101111 (215)
Nuevos Intervalos:
C [178 - 215] ; B [102 – 177]; A [64 - 101]
001(Fijo)00(Descartados)0110100(leídos)
10110100 (180) -> Cae en el rango de la C
Se emite una C.
FIUBA
116
(Orden 1)
●
●
Contexto C: A=1, B=1, C=1  Contexto C: A=2, B=1, C=1
Se plantea el nuevo intervalo(178-215)(Overflow 1 y Underflow -> Cont. UF=1)
Resultado de la normalización(Overflow de 1 y Underflow de 1):
Piso: 10110010 (178) -> 01001000 (72) Techo: 11010111 (215) -> 11011111 (223)
Nuevos Intervalos:
C [173 - 223]; B [122 - 172] ; A [72 – 121]
Debido al Overflow, descartamos el bit que había quedado fijo.
001(Descartado)000(Fijo)1(Descartado)1010010(leídos)
Se emite una A.
●
Piso: 01001000 (72) -> 00100000 (32) Techo: 01111001 (121) -> 11100111 (231)
Nuevos Intervalos:
C [152 - 231] ; B [72 – 151] ; A [32 - 71]
Debido al overflow, descartamos los 2 1eros bits leídos anteriormente y leemos 2 mas del archivo: 0010001101001000(Leidos)
01001000 -> Cae en el rango (es el piso) de la B
Se FIUBA
emite una B.
117
Referencias
●
FIUBA
Gordon Cormack and Nigel Horspool, "Data
Compression using Dynamic Markov Modelling",
Computer Journal 30:6 (December 1987)
118
Algoritmo PPMC
(Prediction by Partial
Matching Mode C)
FIUBA
119
Algoritmo PPMC
(Predictor)
• Compresor predictor con base estadística (utiliza
un aritmético).
• No utiliza un solo contexto para comprimir, sino
varios para una mejor predicción (hasta 6).
• Soluciona algunas de las desventajas de utilizar
contextos.
FIUBA
120
Algoritmo PPMC
(Predictor)
• Problema de utilización de contextos al inicializar
todos los caracteres en forma equiprobable.
• En el contexto del carácter “Q”, una “U” debería
tener probabilidad casi 1.
• Luego de 20 veces de encontrado el patrón, la
probabilidad es de, solamente, 21/277.
• Es muy ineficiente, aprende lento.
FIUBA
121
Algoritmo PPMC
(Predictor)
• Si inicializamos los caracteres en frecuencia 0,
no tenemos probabilidades para emitir.
• Se agrega un carácter especial (carácter de
ESCAPE), que se inicializa con frecuencia 1.
• Cuando no se encuentra el carácter a emitir en el
contexto actual, se emite un ESCAPE y se
actualiza la tabla.
FIUBA
122
Algoritmo PPMC
(Predictor)
• Compresión:
• Se usan varios contextos.
• Se comienza desde el contexto de mayor orden y si el
carácter a emitir se encuentra con probabilidad 0, se
emite un ESCAPE y se va al contexto
inmediatamente menor.
• El último contexto es el -1. Contiene a los 256
caracteres ASCII y al EOF con frecuencia 1 (fija para
todos).
FIUBA
123
Algoritmo PPMC
(Predictor)
• Exclusión:
– Se excluye del contexto actual, los caracteres leídos
en contextos anteriores.
– Si pasé por un contexto donde hubo caracteres con
frecuencia mayor a 0 y no los utilicé, tampoco los
necesito en la tabla del contexto actual.
– Aplicar exclusión mejora el nivel de compresión.
FIUBA
124
Algoritmo PPMC
(Predictor)
• Para la emisión se utiliza un compresor aritmético
que aprovecha las distribuciones de probabilidad
del contexto en el que estoy parado para emitir.
• Comienza con el intervalo inicial, y va emitiendo
y normalizando siempre el mismo intervalo para
cada contexto (no se utilizan intervalos diferentes
para cada uno)
FIUBA
125
Algoritmo PPMC
(Predictor)
• Cuando se pasa de la emisión de un contexto a
otro se hace “zoom” sobre el intervalo actual para
la emisión correspondiente y, para el próximo
contexto, se utiliza el subintervalo obtenido
(normalizado).
• La salida en bits es la del compresor aritmético.
Se debe agregar información de control sobre el
mayor orden de contexto utilizado.
FIUBA
126
Algoritmo PPMC
(Predictor)
• Descompresión:
– Se toma la tira de bits emitida por el aritmético y se
descomprime según éste.
– Con cada emisión que se obtiene, se van
actualizando las tablas de los contextos, de la misma
forma en que se comprimió.
FIUBA
127
• Ejemplo:
Algoritmo PPMC
(Predictor)
– Orden: 2. Fuente: DIVIDIDOS
CTX -1
CTX 0
ASCII 0 - ASCII 255 +
EOF
ESC(1)
CTX 1
D|
CTX 2
ESC(1)
ESC(1/2), D(1/2)
D | ESC(1/2), I(1/2)
--------------------------I|
ESC(1)
DI |
FIUBA
Lectura
ESC(1), D(1/257)
D
ESC(1), ESC(1/2),
I(1/256)
I
ESC(1), ESC(1),
ESC(2/4), V(1/255)
V
ESC(1), ESC(1), I(1/6)
I
ESC(1)
ESC(2/4), D(1/4),
I(1/4)
ESC(3/6), D(1/6),
I(1/6), V(1/6)
Emisión
I | ESC(1/2), V(1/2)
--------------------------- DI |
ESC(1/2), V(1/2)
V|
ESC(1)
---------------------------------IV |
ESC(1)
128
Algoritmo PPMC
(Predictor)
V | ESC(1), I(1/2)
ESC(3/7), D(1/7),
I(2/7), V(1/7)
I|
ESC(2/4),
V(1/4), D(1/4)
ESC(3/8), D(2/8),
I(2/8), V(1/8)
D | ESC(1/3),
I(2/3)
I|
ESC(2/5),
V(1/5), D(2/5)
FIUBA
IV |
ESC(1/2), I(1/2)
-------------------------------- ESC(1), ESC(1/2),
VI |
ESC(1)
D(1/6)
D
VI |
ESC(1/2),
D(1/2)
-------------------------------ID |
ESC(1)
ESC(1), I(1/2)
I
ID |
I(1/2)
ESC(1/2), D(1/3)
D
ESC(1/2), ESC(1),
ESC(3/6), O(1/254)
O
ESC(1/2),
DI |
ESC(2/4),
V(1/4), D(1/4)
ESC(4/10), D(2/10),
I(2/10), V(1/10),
O(1/10)
D|
ESC(2/5),
I(2/5), O(1/5)
------------------------O|
ESC(1)
ID |
ESC(2/4),
I(1/4), O(1/4)
-------------------------------- ESC(1), ESC(1),
DO |
ESC(1)
ESC(4/10), S(1/253)
S
ESC(5/12), D(2/12),
I(2/12), V(1/12),
O(1/12), S(1/12)
O|
ESC(1/2),
S(1/2)
------------------------S|
ESC(1)
DO |
ESC(1/2),
S(1/2)
-------------------------------- ESC(1), ESC(1),
OS | ESC(1)
ESC(5/12), EOF(1/252)
EOF
129
Algoritmo PPMC
(Predictor)
●
Emisión de los primeros 4 caracteres (DIVI)
●
●
●
●
FIUBA
D es el carácter ASCII número 68, I es el número 73
y V es el 86
Usaremos precisión de 10 bits para que sea
suficiente
El carácter EOF se toma como el número 257, por lo
que será el de techo más alto
Los ESC(1) no hace falta indicarlos dado que no
modifican el intervalo (no se emite ningún bit)
130
Algoritmo PPMC
(Predictor)
EOF
1023(1111111111)
1023(1111111111)
|
|
|
|
|
...
D
ESC
…
|
|
| 512 (1000000000)
| 273 (0100010001)
|
|
|
|
ASCII 0
|
D
UN=3
0 (0000000000)
Emisión: 01000
|
| 291 (0100100011)
I
|
| 288 (0100100000)
…
|
|
|
|
|
|
UN=0
0 (0000000000)
-
|
|
|
…
FIUBA
EOF
|
| 270 (0100001110)
1023(1111111111)
1 000
ASCII 0 |
0 (0000000000)
-
01001000 - …
131
Algoritmo PPMC
(Predictor)
1023(1111111111)
|
EOF
|
…
ESC |
|
| 512(1000000000)
I
V
1023(1111111111)
639(1001111111)
|
|
|
|
|
|
|
|
| 337 (0101010001)
|
|
…
|
|
ASCII 0 |
Emisión:
FIUBA
1
| 297 (0100101001)
I
|
0101010
UN=2
| 213 (0011010101)
D
0 (0000000000)
-
|
UN=0
|
0 (0000000000)
V
|
UN=0
D
|
| 340 (0101010100)
|
|
ESC
|
128 (0010000000)
-
0 -…
132
Algoritmo PPMC
(Predictor)
●
Aclaración:
●
FIUBA
Cuando codificamos la “I” con 1/256 de probabilidad,
es porque excluimos al carácter “D”. Esto implica que
la “I” pase a ser el carácter número 72 de nuestro
intervalo. Lo mismo sucede cuando emitimos la “V”,
que pasa a ser el carácter número 84 de nuestro
intervalo por exclusión de la “D” y la “I”)
133
Algoritmo PPMC
(Predictor)
• Mientras mas alto el orden, mejor nivel de
compresión?
• La experiencia dicta que el óptimo está entre
orden 4 y 5.
• Órdenes mas grandes agregan overhead por la
emisión de ESCAPES.
FIUBA
134
Algoritmos de
Compresión
Híbridos
FIUBA
135
Half Coding
FIUBA
136
Half Coding
• Combina compresión run-length con
estadística (Huffman)
• Sólo es eficiente cuando un carácter es
muy repetido, más que el 50% de
ocurrencias
• Para caracteres tan frecuentes, Huffman no
es efectivo porque no puede codificar con
menos de 1 bit
• Puede ser estático o dinámico
FIUBA
137
Half Coding
• Se codifica la longitud del carácter más
probable
• Por cada ocurrencia, se escribe su longitud
en binario, se le suma 1, se le quita el bit
más significativo (un 1) y se reemplaza
0=α y 1=β:
1=α, 2=β, 3=αα, 4=αβ, 5=βα, 6=ββ…
• Se trata a α y β como dos caracteres más
y se los codifica con Huffman
FIUBA
138
Half Coding: ejemplo estático
Ejemplo:
AAAABAACAAAAAAACDAAA
● Con Huffman estático se comprimiría a 26 bits:
●
1-1-1-1-010-1-1-00-1-1-11-1-1-1-00-011-1-1-1
●
Con Half Coding se convierte a:
αβBβCαααCDαα
y se comprime a 24 bits:
0-111-100-111-110-0-0-0-110-101-0-0
FIUBA
139
LZHuff
FIUBA
140
LZHuff
• Es un LZ77 que utiliza árboles de Huffman
P5
Caracteres
Longitudes
(literals)
(lenghts)
P4
P3
P2
P1
Posiciones
(distances)
• Ahora no necesito un bit más para distinguir
entre duplas y caracteres
FIUBA
141
LZHuff
• Compresión:
• El método de compresión es el mismo,
solo cambia la forma de emitir los
resultados.
• Si caí en el sector de la longitud lo
próximo que voy a leer es algo del árbol
de posiciones.
• Voy leyendo de a un bit y cuando llego
a una hoja paro de leer y paso al
siguiente.
FIUBA
142
LZHuff
• Si hay longitudes que se repiten mucho, este
método hace que se emitan con menos bits.
• La cantidad de longitudes y posiciones que
se pueden usar esta pre-definida.
• Se usan códigos mas cortos para posiciones
mas altas, ya que las repeticiones se dan en
lo mas recientemente comprimido. Hay que
definir distribución de probabilidades para el
árbol estático.
FIUBA
143
LZP
FIUBA
144
LZP
• Creado por Charles Bloom en 1994. Le
agrega predicción al algoritmo de los LZ.
• La idea es solucionar los problemas de
LZ77:
• Tiempo de búsqueda de substrings en
ventana de inspección
• Bits emitidos por posiciones
• Agregar un factor estadístico mejora los
resultados (Ejemplo: LZHuff)
FIUBA
145
LZP
• Directamente no emito las posiciones.
• Predigo posición de match, según el contexto.
• Siempre pongo la longitud (puede ser 0)
• Las actualizaciones de los contextos se
mantienen en una tabla.
FIUBA
146
LZP
0
1
2
3
4
5
6
7
8
9
10
L
A
L
A
L
A
L
A
A
A
A
Posición
Lectura
Contexto
Comparar
0
L
-
1
A
2
3
Arit Din O(0)
Arit Din O(1)
Salida
Actualiz.
Long
Contexto
Carácter
-
0
\b
L
-
-
-
0
L
A
-
L
LA
-
0
A
L
LA = 2
A
AL
-
0
L
A
AL = 3
…
0
0
A
0
L
L
Contexto 2
Long.
FIUBA
\b
Long.
L
Long.
A
147
LZP
• Utiliza un aritmético de orden 0 para emitir las
longitudes y un aritmético de orden 1 para emitir
los caracteres
• Se suelen usar longitudes de 0 a 255
• Debemos especificar la longitud de contexto que
utilizaremos y almacenarla como información de
control
• Al identificar un contexto previamente encontrado,
se verifica en el archivo la posición donde se
encontró ese contexto por ultima vez y se lee el
archivo comparando con la lectura actual, para
encontrar matches de la mayor longitud posible.
FIUBA
148
LZP
• Ejemplo:
• Fuente: AAAAAANTANANARIVO
• Longitud de contexto: 2
• Vocabulario: {A,I,N,O,V,R}
• Longitudes posibles de match: L0 - L4
• Precisión del aritmético: 8 bits
• Solamente se mostrarán los primeros
cuatro pares de emisiones de bits.
FIUBA
149
LZP
Posición
FIUBA
Contexto
Comparar con pos
Salida
Actualización
0
--
--
Long 0 - (\b,A)
--
1
--
--
Long 0 - (A,A)
--
2
AA
--
Long 0 - (A,A)
AA=2
3
AA
2
Long 3 - (A,N)
AA=3
7
AN
--
Long 0 - (N,T)
AN=7
8
NT
--
Long 0 - (T,A)
NT=8
9
TA
--
Long 0 - (A,N)
TA=9
10
AN
7
Long 0 - (N,A)
AN=10
11
NA
--
Long 0 - (A,N)
NA=11
12
AN
10
Long 1 - (A,R)
AN=12
14
AR
--
Long 0 - (R,I)
AR=14
15
RI
--
Long 0 - (I,V)
RI=15
16
IV
--
Long 0 - (V,O)
IV=16
17
VO
--
Long 0 - (O,EOF)
150
LZP
●
Compresión de AAAAAANTANANARIVO:
Compresión de Longitud 0:
●
L0=1, L1=1, L2=1 , L3=1 , L4=1  L0=2, L1=1, L2=1 , L3=1 , L4=1
N.Piso = 0 + 256 * 0 = 0 N. Techo = 0 + 256 * 1 / 5 - 1 = 50
Piso: 00000000 (0) -> 00000000 (0) Techo: 00110010 (50) -> 11001011 (203)
Emisión: 00
C. underflow: 0
Compresión del caracter ‘A' – Contexto \b
●
Contexto \b: A=1, I=1, N=1, O=1, V=1, R=1, EOF=1
N.Piso = 0 + 204 * 0 / 7 = 0 N. Techo = 0 + 204 * 1 / 7 - 1 = 28
Piso 00000000 (0) -> 00000000 (0) Techo: 00011100 (28) -> 11100111 (231)
Emisión: 000
C. underflow: 0
FIUBA
151
LZP
●
●
L0=2, L1=1, L2=1 , L3=1 , L4=1  L0=3, L1=1, L2=1 , L3=1 , L4=1
N.Piso = 0 + 232 * 0 = 0 N. Techo = 0 + 232 * 2 / 6 - 1 = 76
Piso: 00000000 (0) -> 00000000 (0) Techo: 01001100 (76) -> 10011001 (153)
Emisión: 0
C. underflow: 0
Compresión del caracter ‘A' – Contexto A
●
Contexto A: A=1, I=1, N=1, O=1, V=1, R=1, EOF=1  Contexto A: A=2, I=1, N=1, O=1, V=1, R=1, EOF=1
N.Piso = 0 + 154 * 0 / 7 = 0 N. Techo = 0 + 154 * 1 / 7 - 1 = 21
Piso 00000000 (0) -> 00000000 (0) Techo: 00010101 (21) -> 10101111 (175)
Emisión: 000
C. underflow: 0
FIUBA
152
LZP
●
●
L0=3, L1=1, L2=1 , L3=1 , L4=1  L0=4, L1=1, L2=1 , L3=1 , L4=1
N.Piso = 0 + 176 * 0 = 0 N. Techo = 0 + 176 * 3 / 7 - 1 = 74
Piso: 00000000 (0) -> 00000000 (0) Techo: 01001010 (74) -> 10010101 (149)
Emisión: 0
C. underflow: 0
Compresión del caracter ‘A' – Contexto A
●
N.Piso = 0 + 150 * 0 / 8 = 0 N. Techo = 0 + 150 * 2 / 8 - 1 = 36
Piso 00000000 (0) -> 00000000 (0) Techo: 00100100 (36) -> 10010011 (147)
Emisión: 00
C. underflow: 0
FIUBA
153
LZP
●
●
L0=4, L1=1, L2=1 , L3=1 , L4=1  L0=4, L1=1, L2=1 , L3=2 , L4=1
N.Piso = 0 + 148 * 6 / 8 = 111 N. Techo = 0 + 148 * 7 / 8 - 1 = 128
Piso: 01101111 (111) -> 00111100 (60) Techo: 10000000 (128) -> 10000011 (131)
Emisión:
C. underflow: 2
Compresión del caracter ‘N' – Contexto A
●
N.Piso = 60 + 72 * 4 / 9 = 92 N. Techo = 60 + 72 * 5 / 9 - 1 = 99
Piso 01011100 (92) -> 00000000 (0) Techo: 01100011 (99) -> 11111111 (255)
Emisión: 0111
C. underflow: 3
FIUBA
154
Técnicas de
Optimización de la
Compresión
FIUBA
155
Block Sorting
FIUBA
156
Block Sorting
• También llamada Burrows-Wheeler
• Es una transformación que no comprime,
incluso expande la fuente
• Obtiene una permutación de caracteres
para mejorar la localidad
• La salida, con más localidad, es apropiada
para ingresar al algoritmo Move to Front
FIUBA
157
Block Sorting
• Se colocan todas las permutaciones de la
fuente en una matriz, desplazando un
carácter más en cada fila
• Se ordenan alfabéticamente las filas
• Se emiten la última columna y el índice de
la fila correspondiente a la fuente original
FIUBA
158
Block Sorting
Fuente: SALALALASARAS
FIUBA
159
Block Sorting
Antitransformación
• Se intenta
reconstruir la
matriz, primero se
escribe la última
columna
S
L
L
S
L
R
A
A
A
A
S
A
A
FIUBA
160
Block Sorting
Antitransformación
• Se intenta
reconstruir la
matriz, primero se
escribe la última
columna
• Se la reordena y se
obtiene la primera
FIUBA
A
S
A
L
A
L
A
S
A
L
A
R
L
A
L
A
L
A
R
A
S
S
S
A
S
A
161
Block Sorting
Antitransformación
• Se intenta reconstruir
la matriz, primero se
escribe la última
columna
• Se la reordena y se
obtiene la primera
• Se concatena la última
y la primera, se la
reordena y se obtiene
la segunda
FIUBA
A
L
S
A
L
L
A
L
L
A
R
S
A
S
L
A
S
R
L
A
A
L
A
A
L
A
A
R
A
A
S
A
S
S
A
A
S
S
A
162
Block Sorting
Antitransformación
• Se intenta reconstruir la matriz, primero se
escribe la última columna
• Se la reordena y se obtiene la primera
• Se concatena la primera y última, se la
reordena y se obtiene la segunda
• Se repiten los pasos hasta obtener toda la
matriz
FIUBA
• La fila indicada por el índice es la fuente
original
163
Move To Front
FIUBA
164
Move To Front
• Es una transformación que no comprime
• Reduce la entropía de la fuente aumentando
la probabilidad de unos símbolos por sobre la
de otros
• Sólo funciona bien si la fuente tiene mucha
localidad
FIUBA
• El índice recibido desde el Block Sorting no es
transformado Organización de Datos - Curso Servetto
165
Move To Front
• Si su entrada es apropiada, su salida es
mucho más adecuada para ser comprimida
por algunos compresores estadísticos, y en
algunos casos, por un compresor half
coding
• Tiene la propiedad de transformar
repeticiones de cualquier carácter en
números bajos. Cuanto más cerca la
repetición, más bajo el número
FIUBA
166
Move To Front
• Se codifica el alfabeto de la forma
estándar (sin comprimir), por lo que a cada
símbolo le corresponde un número. Se arma
un array con los números.
• Se van leyendo símbolos de la fuente
según la codificación. Por cada símbolo que
se lee, se emite su posición en el array, y
se mueve ese símbolo a la posición 0 del
array (el frente)
FIUBA
167
Move To Front
SALALALASARAS, luego del BS se
transforma en SLLSRAAAASAA-10
FIUBA
168
Move To Front
• Antitransformación:
• Se vuelve a construir el array con las
codificaciones del alfabeto
• Se va leyendo a la entrada, donde cada
lectura es una posición. Se emite el símbolo
encontrado en la posición leída, y se pasa
el símbolo al frente del array.
FIUBA
169
Modelo de Shannon
FIUBA
170
Modelo de Shannon
• Es un compresor que utiliza como base el
aritmético, emitiendo en cada paso según la
distribución de probabilidad que corresponda
al Match o Escape correspondiente
• Se comporta muy bien si la fuente es la
salida de un BS+MTF
• Utiliza 6 modelos (o contextos) numerados,
de los cuales 5 matchean con un solo símbolo
• El único otro símbolo de esos modelos es el
ESC
FIUBA
171
Modelo de Shannon
• Los modelos 0 y 1 matchean con el
símbolo 0, es decir, emiten M si el símbolo
es 0, ESC si otro
• El modelo 2 matchea con el símbolo 1
• El modelo 5 matchea con el resto de los
símbolos
FIUBA
172
Modelo de Shannon
• El modelo 0 se utiliza al principio, y cuando
recién hubo un match para el símbolo 0
• El modelo 1 se utiliza en el resto de los
casos
• Cuando ocurre un ESC en un modelo, se
busca en el modelo siguiente
• Los modelos son dinámicos, por lo que
actualizan las frecuencias en cada paso
• Los modelos 0 y 1 nunca se utilizan en el
mismo paso
FIUBA
173
Modelo de Shannon
FIUBA
174
Modelo Estructurado
FIUBA
175
Modelo Estructurado
• Es un compresor que utiliza como base el
aritmético, de la misma forma que el Modelo
de Shannon
• Se comporta muy bien si la fuente es la
salida de un BS+MTF
• Utiliza 9 modelos (o contextos)
numerados, donde los más altos matchean
con más cantidad de símbolos
FIUBA
176
Modelo Estructurado
• Siempre se empieza del modelo 0
• Matches:
FIUBA
177
Modelo Estructurado
FIUBA
178
Comparación de Compresores
• A la salida de BS+MTF, se pueden aplicar
tres compresores que obtienen buenos
resultados:
• Modelo estructurado
• Modelo de Shannon
• Half Coding
• Los tres se benefician de las apariciones
del carácter 0
FIUBA
179
Comparación de Compresores
• Half Coding se beneficia más que los
otros dos compresores con la abundancia
de 0s. Los otros dos se benefician por
igual
• Si hay abundancia de caracteres de
valores intermedios (por ejemplo 4, 7 o
20) el modelo de Shannon comprime peor
que el estructurado
FIUBA
180
Algoritmos de
Compresión Con
Pérdida
(Lossy)
Compactación de imágenes: JPEG
Compactación de vídeo: MPEG
FIUBA
181
Con Pérdida
(Lossy)
• La naturaleza de los datos multimedia es brindar información
directa a una persona. Las personas, tenemos límites en la
percepción.
• El cerebro humano compensa estas deficiencias, integrando la
información. Así, podemos seleccionar la información que menos
se percibe y eliminarla.
• Los periféricos, transmiten información a otros periféricos,
captando todos los datos enviados.
• Para el humano, la pérdida de esta información es inapreciable,
mientras que para un periférico es cuantiosa.
FIUBA
182
Con Pérdida
(Lossy)
• Los archivos multimedia (de video) son muy
“pesados” debido a su naturaleza.
• Su representación más sencilla es la sucesión
de cuadros, cada uno de los cuales se
representa como una matriz de píxeles.
• El video a color utiliza 8 bits por pixel para
cada color RGB (Red, Green, Blue), 16
millones de colores en total.
FIUBA
183
Con Pérdida
(Lossy)
• Para que el ojo humano observe movimiento
continuo, se deben exhibir 25 cuadros/s.
• Para una pantalla de 1024 x 768, teniendo 24
bits por pixel, necesito alimentar el monitor
con 472 Mbps.
• Un video de 2 horas, con esta tasa, ocuparía
casi 400 Gb.
FIUBA
184
Con Pérdida
(Lossy)
• Se necesitan técnicas de compresión
(compactación en este caso) para el video.
• En este tipo de técnicas, la codificación y la
decodificación van a ser bastante asimétricas.
• El archivo multimedia solo se codificará una
vez y se decodificará muchas veces.
• Al decodificar, el resultado será distinto al
original  hay pérdida de información
FIUBA
185
JPEG
FIUBA
186
JPEG
• JPEG (Joint Photographic Experts Group) es un
estándar para comprimir imágenes.
• Se utiliza como parte del estándar MPEG para
comprimir video.
• Tiene 4 modos, pero nos ocuparemos del que se
usa con video RGB de 24 bits.
• Las tasas de compresión pueden ser entre 20:1
y 25:1 sin notar degradaciones importantes,
mientras que en las técnicas sin pérdida podrían
rondar los 10:1.
FIUBA
187
JPEG
• Además de RGB, existe otra forma de
representar el color con una señal de
luminancia (brillantez) y dos de crominancia
(color).
• El ojo humano es mucho mas sensible a las
señales de luminancia que a las de
crominancia. Por esto, las dos últimas no
tienen por qué transmitirse con tanta
precisión.
FIUBA
188
JPEG (codificación)
• 1er paso: Preparación de los bloques
• Teniendo una imagen RGB de 640 x 480, con 24
bits por pixel.
• Sabiendo que las señales de luminancia y
crominancia producen mejor compresión, se
calculan a partir de los valores de RGB.
• Estas se llaman Y (luminancia), I y Q
(crominancia) en el caso que veremos (NTSC).
FIUBA
189
• Se construyen matrices individuales para Y, I y Q.
Cada una con elementos dentro del intervalo 0 –
255 (8 bits). No se comprime nada hasta aquí.
• Se promedian bloques cuadrados de cuatro
pixeles en las matrices I y Q (quedando 320x240)
• Esta reducción produce pérdidas, pero el ojo casi
no lo nota debido a que es más sensible a la
luminancia.
FIUBA
190
• Se resta 128 a cada elemento de las 3 matrices
para que el 0 quede a mitad del intervalo.
• Se divide cada matriz en bloques de 8x8.
FIUBA
191
• 2do paso: Transformación discreta del coseno
• A cada uno de los bloques por separado se aplica
la DCT. El resultado es una matriz de 8x8
coeficientes DCT.
• El elemento DCT (0,0) es el valor promedio del
bloque.
• En teoría este paso no produce pérdidas, pero
siempre existe un pequeño error de redondeo.
FIUBA
192
• 2do paso: Transformación discreta del coseno
• El valor promedio es el más alto del bloque, y el
resto decae rápidamente a medida que se aleja
del origen.
FIUBA
193
• 3er paso: Cuantización
• Se eliminan los elementos DCT menos
importantes. Produce pérdidas.
• Se divide cada elemento DCT de cada matriz 8x8
por un peso correspondiente a la misma posición,
tomado de una tabla de cuantización.
• La tabla no es parte del estándar, por lo que sus
pesos pueden variar dependiendo del grado de
pérdida/compresión que se desee dar.
FIUBA
194
• 3er paso: Cuantización
FIUBA
195
• 4to paso: Reducción del valor promedio
• Redice el valor (0,0) de cada bloque,
sustituyéndolo por su diferencia con el elemento
(0,0) del bloque anterior.
• Es de esperarse que el cambio entre un bloque y
otro sea gradual, por lo que las diferencias serán
pequeñas.
FIUBA
196
• 5to paso: Linealización del bloque
• Explora los elementos del bloque en zigzag,
comenzando por el elemento origen.
• Con esto, términos parecidos y tiras de ceros se
obtienen juntos.
FIUBA
197
• 6to paso: Compresión
• Al resultado obtenido por la linealización, se le
aplica un compresor tipo run-length para
aprovechar seguidillas de valores repetidos.
• A la lista de números que representan la imagen
completa, se le aplica el método de compresión
estadística de Huffman, para almacenar o
transmitir los datos.
FIUBA
198
MPEG
FIUBA
199
MPEG
• MPEG (Motion Pictures Experts Group) es un
conjunto de estándares para comprimir video.
• MPEG-1 está diseñado para obtener salidas
con calidad videograbadora (352x240), tasa
de 1.2 Mbps.
• MPEG-2, del que nos ocuparemos, comprime
video con calidad de difusión entre 4 y 6
Mbps.
FIUBA
200
MPEG
• Esta técnica de compresión aprovecha los dos
tipos de redundancia presente en los videos:
• Redundancia espacial: se codifican los cuadros utilizando
JPEG
• Redundancia temporal: cuadros consecutivos suelen ser casi
idénticos, muchas veces los cambios son pequeños
• Por otro lado, se buscan resolver dos problemas:
• Movimiento de objetos: imagen fija, objetos en movimiento
• Movimiento del observador: imagen en movimiento
FIUBA
201
MPEG
• La salida consiste en 3 tipos de cuadro:
• Cuadros I (intracodificados): imágenes fijas
independientes, codificadas por JPEG.
• Cuadros P (predictivos): diferencias, bloque por
bloque, respecto al cuadro anterior.
• Cuadros B (bidireccionales): diferencias respecto
al cuadro anterior y al siguiente.
FIUBA
202
MPEG
• Cuadros I
• Se codifica directamente una imagen por medio
de JPEG como vimos anteriormente.
• Resuelven la redundancia espacial en el video.
• Son necesarios en forma periódica:
• Para poder sintonizar en cualquier momento
• En caso que algún cuadro contenga errores
• Avance rápido y rebobinado
FIUBA
203
MPEG
• Cuadros P
• Codifican diferencias entre cuadros. Se buscan
macrobloques, de 16x16 pixeles de luminancia y
8x8 de crominancias.
• Cada macrobloque se codifica buscando uno
igual o casi igual en el cuadro anterior.
FIUBA
204
MPEG
• Cuadros P
• El estándar MPEG no especifica cómo hacer la búsqueda,
qué tan lejos buscar, ni qué tan exacta debe ser la
coincidencia para identificar un match.
• Si se encuentra un macrobloque, se codifica calculando la
diferencia respecto al del cuadro anterior, utilizando JPEG.
Se agrega, además, el vector de movimiento, que indica
qué tanto se movió el macrobloque.
• Si no hay coincidencia, se codifica el macrobloque con
JPEG, tal como los cuadros I.
• Ayuda a resolver el problema del movimiento de objetos
entre cuadros consecutivos.
FIUBA
205
MPEG
• Cuadros B
• Similares a los P, pero permiten que el macrobloque se
encuentre en el cuadro siguiente (que podría ser I o P).
• Permite compensar mejor el movimiento, resolviendo el
problema de movimiento del observador, presente en el
video.
• Para codificarlos, es necesario almacenar 3 cuadros en
memoria (anterior, actual y futuro)
• Los cuadros deberán almacenarse en orden de
dependencia y no de exhibición. Será necesario el uso de
buffers para reordenarlos al exhibirlos.
FIUBA
206
Referencias
●
FIUBA
A. S. Tanenbaum, "Sistemas Operativos
Modernos, Segunda Edición", Prentice Hall.
ISBN 0-13-031358-0, 976 páginas.
207

Compresión de Datos

Transcripción

Documentos relacionados

Implementación de Sistemas Embebidos

Protocolos y comunicaciones, Robótica, RTOS y Software

Formatos gráficos. 1ª Parte

SRP - 350 - TiendaTPV.com

- Subterra-ing