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.
Organización de Datos - Curso Servetto
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
Organización de Datos - Curso Servetto
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
Organización de Datos - Curso Servetto
6
Teoría de la Información
●
Información (definición cuantitativa)
●
FIUBA
Shannon 1948 – matemática estadística.
Organización de Datos - Curso Servetto
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
Organización de Datos - Curso Servetto
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
Organización de Datos - Curso Servetto
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)
Organización de Datos - Curso Servetto
10
Representación de los Datos
(códigos de representación).
●
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
Organización de Datos - Curso Servetto
Representación de los Datos
(códigos de representación).
●
Clasificación por longitud
–
Longitud Fija
●
Los ASCII:
0011 1000
0011 1110
–
Longitud Variable:
●
Los UNICODE variables:
100 1110
110 101000
FIUBA
Organización de Datos - Curso Servetto
12
Representación de los Datos
(códigos de representación).
●
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
Organización de Datos - Curso Servetto
13
Representación de los Datos
(códigos de representación).
●
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.
Organización de Datos - Curso Servetto
14
Representación de los Datos
(códigos de representación).
●
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
Organización de Datos - Curso Servetto
15
Referencias
●
FIUBA
David Salomon , “A Concise Introduction to Data
Compression ”, Springer-Verlag London Limited
2008 , pp 21-29.
Organización de Datos - Curso Servetto
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.
Organización de Datos - Curso Servetto
17
Algoritmos de Codificación
●
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.
Organización de Datos - Curso Servetto
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.)
Organización de Datos - Curso Servetto
19
Algoritmos de Codificación
●
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.
Organización de Datos - Curso Servetto
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.
Organización de Datos - Curso Servetto
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
Organización de Datos - Curso Servetto
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”.
Organización de Datos - Curso Servetto
23
Algoritmos de
Compresión Sin
Pérdida
(Lossless)
Estadísticos
Por Diccionario
Predictores
Híbridos
FIUBA
Organización de Datos - Curso Servetto
24
Algoritmos de
Compresión
Estadísticos
Algoritmo de Huffman
Algoritmo Aritmético
FIUBA
Organización de Datos - Curso Servetto
25
Algoritmo de Huffman
(Estadístico)
FIUBA
Organización de Datos - Curso Servetto
26
Algoritmo de Huffman
(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.
Organización de Datos - Curso Servetto
27
Algoritmo de Huffman
(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
Organización de Datos - Curso Servetto
28
Algoritmo de Huffman
(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
Organización de Datos - Curso Servetto
29
Algoritmo de Huffman
(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
Organización de Datos - Curso Servetto
30
Algoritmo de Huffman
(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
Organización de Datos - Curso Servetto
31
Algoritmo de Huffman
(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
Organización de Datos - Curso Servetto
32
Algoritmo de Huffman
(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
Organización de Datos - Curso Servetto
33
Algoritmo de Huffman
(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
Organización de Datos - Curso Servetto
34
Algoritmo de Huffman
(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
Organización de Datos - Curso Servetto
35
Algoritmo de Huffman
(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
Organización de Datos - Curso Servetto
---- ---- I
---- ---- C
---- E
36
Algoritmo de Huffman
(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
Organización de Datos - Curso Servetto
37
Algoritmo de Huffman
(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
Organización de Datos - Curso Servetto
38
Algoritmo de Huffman
(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
Organización de Datos - Curso Servetto
39
Algoritmo de Huffman
(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)
Organización de Datos - Curso Servetto
40
Algoritmo de Huffman
(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
Organización de Datos - Curso Servetto
41
Algoritmo de Huffman
(método dinámico)
●
Descompresión(Cont.):
●
FIUBA
Arboles finales generados en cada paso de la
tabla:
Organización de Datos - Curso Servetto
42
Algoritmo de Huffman
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)
Organización de Datos - Curso Servetto
43
Algoritmo de Huffman
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
Organización de Datos - Curso Servetto
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
Organización de Datos - Curso Servetto
45
Algoritmo de Huffman
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
Organización de Datos - Curso Servetto
46
Algoritmo de Huffman
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
Organización de Datos - Curso Servetto
47
Algoritmo de Huffman
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
Organización de Datos - Curso Servetto
48
Algoritmo de Huffman
Manejo Eficiente
(método dinámico)
●
Ejemplo de compresión(fte: porotosEOF)
●
Arbol inicial(vocabulario o,p,r,s,t,EOF):
FIUBA
Organización de Datos - Curso Servetto
49
Algoritmo de Huffman
Manejo Eficiente
(método dinámico)
●
Ejemplo de compresión(fte: porotosEOF)
1) Arbol Inicial
2)Lectura p(Emisión 10)
3) Lectura o(Emision 11)
4)Lectura r(Emisión 011)
FIUBA
Organización de Datos - Curso Servetto
50
Algoritmo de Huffman
Manejo Eficiente
(método dinámico)
●
Ejemplo de compresión(fte: porotosEOF)
5) Lectura o(Emision 11)
6)Lectura t(Emisión 001)
7) Lectura o(Emision 01)
8)Lectura s(Emisión 110)
FIUBA
Organización de Datos - Curso Servetto
51
Algoritmo de Huffman
Manejo Eficiente
(método dinámico)
●
Ejemplo de compresión(fte: porotosEOF)
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.
Organización de Datos - Curso Servetto
52
Algoritmo de Huffman
Manejo Eficiente
(método dinámico)
●
Ejemplo de descompresión(fte: porotosEOF)
●
Arbol inicial(vocabulario o,p,r,s,t,EOF):
FIUBA
Organización de Datos - Curso Servetto
53
Algoritmo de Huffman
Manejo Eficiente
(método dinámico)
●
Ejemplo de descompresión(fte: porotosEOF)
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.
Organización de Datos - Curso Servetto
54
Algoritmo de Huffman
Manejo Eficiente
(método dinámico)
●
Ejemplo de descompresión(fte: porotosEOF)
FIUBA
●
El método es similar a la descompresión explicada anteriormente.
●
3) Se lee bit 0, luego bit 1 y bit 1 -> se emite r-> se actualiza el arbol.
●
4) Se lee bit 1, luego bit 1 -> se emite o-> se actualiza el arbol.
Organización de Datos - Curso Servetto
55
Algoritmo de Huffman
Manejo Eficiente
(método dinámico)
●
Ejemplo de descompresión(fte: porotosEOF)
FIUBA
●
El método es similar a la descompresión explicada anteriormente.
●
5) Se lee bit 0, luego bit 0 y bit 1 -> se emite t-> se actualiza el arbol.
●
6) Se lee bit 0, luego bit 1 -> se emite o-> se actualiza el arbol.
Organización de Datos - Curso Servetto
56
Algoritmo de Huffman
Manejo Eficiente
(método dinámico)
●
Ejemplo de descompresión(fte: porotosEOF)
FIUBA
●
El método es similar a la descompresión explicada anteriormente.
●
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
Organización de Datos - Curso Servetto
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.
Organización de Datos - Curso Servetto
58
Algoritmo de Aritmético
(Estadístico)
FIUBA
Organización de Datos - Curso Servetto
59
Algoritmo Aritmético
(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
Organización de Datos - Curso Servetto
60
Algoritmo Aritmético
(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
Organización de Datos - Curso Servetto
61
Algoritmo Aritmético
(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
Organización de Datos - Curso Servetto
62
Algoritmo Aritmético
(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
Organización de Datos - Curso Servetto
63
Algoritmo Aritmético
(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
Organización de Datos - Curso Servetto
Algoritmo Aritmético
(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
Organización de Datos - Curso Servetto
0000
65
Algoritmo Aritmético
(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
Organización de Datos - Curso Servetto
0100
66
Algoritmo Aritmético
(Estadístico)
Es posible que tras normalizar un overflow,
se descubra un underflow
●
Techo:
Piso:
FIUBA
11011001  11100111
10101110  00111000 (U=1)
Organización de Datos - Curso Servetto
67
Algoritmo Aritmético
(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
Organización de Datos - Curso Servetto
68
Algoritmo Aritmético
(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
Organización de Datos - Curso Servetto
69
Algoritmo Aritmético
(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
Organización de Datos - Curso Servetto
70
Algoritmo Aritmético
(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
Organización de Datos - Curso Servetto
71
Algoritmo Aritmético
(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)
●
Piso inicial: 0 - Techo Inicial 169 Intervalo: 170
N.Piso = 0 + 170 * 0 / 6 = 0 N. Techo = 0 + 170 * 3 / 6 - 1 = 84
Resultado de la normalización:
Piso 00000000 (0) -> 00000000 (0) Techo: 01010100 (84) -> 10101001 (169)
Emisión: 0
C. underflow: 0
FIUBA
Organización de Datos - Curso Servetto
72
Algoritmo Aritmético
(método estático)
●
Compresión de BAABCA:
Compresión del caracter ‘A' - (Posicion: 2)
●
Piso inicial: 0 - Techo Inicial 169 Intervalo: 170
N.Piso = 0 + 170 * 0 / 6 = 0 N. Techo = 0 + 170 * 3 / 6 - 1 = 84
Resultado de la normalización:
Piso: 00000000 (0) -> 00000000 (0) Techo: 01010100 (84) -> 10101001 (169)
Emisión: 0
C. underflow: 0
Compresión del caracter ‘B' - (Posicion: 3)
●
Piso inicial: 0 - Techo Inicial 169 Intervalo: 170
N.Piso = 0 + 170 * 3 / 6 = 85 N. Techo = 0 + 170 * 5 / 6 - 1 = 140
Resultado de la normalización:
Piso: 01010101 (85) -> 00101010 (42) Techo: 10001100 (140) -> 10011001 (153)
Emisión:
C. underflow: 1
FIUBA
Organización de Datos - Curso Servetto
73
Algoritmo Aritmético
(método estático)
●
Compresión de BAABCA:
Compresión del caracter ‘C' - (Posicion: 4)
●
Piso inicial: 42 - Techo Inicial 153 Intervalo: 112
N.Piso = 42 + 112 * 5 / 6 = 135 N. Techo = 42 + 112 * 6 / 6 - 1 = 153
Resultado de la normalización:
Piso: 10000111 (135) -> 00111000 (56) Techo: 10011001 (153) -> 11001111 (207)
Emisión: 1000(Underflow)
C. underflow: 0
Compresión del caracter ‘A' - (Posicion: 5)
●
Piso inicial: 56 - Techo Inicial 207 Intervalo: 152
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
Organización de Datos - Curso Servetto
74
Algoritmo Aritmético
(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
Organización de Datos - Curso Servetto
75
Algoritmo Aritmético
(método estático)
●
Descompresión de BAABCA:
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
Organización de Datos - Curso Servetto
76
Algoritmo Aritmético
(método estático)
●
Descompresión de BAABCA:
Descompresión del caracter ‘A‘
●
Se plantea el nuevo intervalo(0-84)(Overflow de 1)
Resultado de la normalización(Overflow de 1):
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]
Debido al overflow, descartamos el 1er bit leído anteriormente y leemos uno mas del archivo: 1001000001
01000001 -> Cae en el rango de la A
Se emite una A.
Descompresión del caracter ‘B‘
●
Se plantea el nuevo intervalo(0-84)(Overflow de 1)
Resultado de la normalización(Overflow de 1):
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]
Debido al overflow, descartamos el 1er bit leído anteriormente y leemos uno mas del archivo: 10010000011
01000001 -> Cae en el rango de la B
Se emite una B.
FIUBA
Organización de Datos - Curso Servetto
77
Algoritmo Aritmético
(método estático)
●
Descompresión de BAABCA:
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.
Descompresión del caracter ‘A‘
●
Se plantea el nuevo intervalo(135-153)(Overflow de 3)
Resultado de la normalización(Overflow de 3):
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)
00111000 -> Cae en el rango de la A
Se emite una A. Además es el piso del intervalo y sabemos que teniamos 6 caracteres-> Fin.
FIUBA
Organización de Datos - Curso Servetto
78
Algoritmo Aritmético
(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
Organización de Datos - Curso Servetto
79
Algoritmo Aritmético
(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
Organización de Datos - Curso Servetto
80
Algoritmo Aritmético
(Dinamico)
●
Compresión de ABAC:
Compresión del caracter ‘A' - (Posicion: 0)
●
A=1, B=1, C=1  A=2, B=1, C=1
Piso inicial: 0 - Techo Inicial 255 Intervalo: 256
N.Piso = 0 + 256 * 0 = 0 N. Techo = 0 + 256 * 1 / 3 - 1 = 84
Resultado de la normalización:
Piso: 00000000 (0) -> 00000000 (0) Techo: 01010100 (84) -> 10101001 (169)
Emisión: 0
C. underflow: 0
Compresión del caracter ‘B' - (Posicion: 1)
●
A=2, B=1, C=1  A=2, B=2, C=1
Piso inicial: 0 - Techo Inicial 169 Intervalo: 170
N.Piso = 0 + 170 * 2 / 4 = 85 N. Techo = 0 + 170 * 3 / 4 - 1 = 126
Resultado de la normalización:
Piso 01010101 (85) -> 01111110 (126) Techo: 01010100 (84) -> 11111011 (251)
Emisión: 01
C. underflow: 0
FIUBA
Organización de Datos - Curso Servetto
81
Algoritmo Aritmético
(Dinamico)
●
Compresión de ABAC :
Compresión del caracter ‘A' - (Posicion: 2)
●
A=2, B=2, C=1  A=3, B=2, C=1
Piso inicial: 84 - Techo Inicial 251 Intervalo: 168
N.Piso = 84 + 168 * 0 / 5 = 84 N. Techo = 84 + 168 * 2 / 5 - 1 = 150
Resultado de la normalización:
Piso: 01010100 (84) -> 00101000 (40) Techo: 10010110 (150) -> 10101101 (173)
Emisión: -
C. underflow: 1
Compresión del caracter ‘C' - (Posicion: 3)
●
A=3, B=2, C=1  A=3, B=2, C=2
Piso inicial: 40 - Techo Inicial 173 Intervalo: 134
N.Piso = 40 + 134 * 5 / 6 = 151 N. Techo = 40 + 134 * 6 / 6 - 1 = 173
Al ser el ultimo caracter, se emite el piso, incluyendo los underflows: Piso: 10010111 (151) --- > Emisión: 100010111
Emision final: 0-01-100010111
FIUBA
Organización de Datos - Curso Servetto
82
Algoritmo Aritmético
(Dinamico)
●
Descompresión de ABAC:
Descompresión del caracter ‘A‘
●
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.
●
Descompresión del caracter ‘B‘
●
A=2, B=1, C=1  A=2, B=2, C=1
Se plantea el nuevo intervalo(0-84)(Overflow de 0)
Resultado de la normalización(Overflow de 0):
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]
Debido al overflow, descartamos el 1er bit leído anteriormente y leemos uno mas del archivo: 001100010
01100010 (98) -> Cae en el rango de la B
Se emite una B.
FIUBA
Organización de Datos - Curso Servetto
83
Algoritmo Aritmético
(Dinamico)
●
Descompresión de ABAC:
Descompresión del caracter ‘A‘
●
A=2, B=2, C=1  A=3, B=2, C=1
Se plantea el nuevo intervalo(85-126)(Overflow de 01)
Resultado de la normalización(Overflow de 01):
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.
Descompresión del caracter ‘C‘
●
A=3, B=2, C=1  A=3, B=2, C=2
Se plantea el nuevo intervalo(84-150)(Underflow de 1)
Resultado de la normalización(Underflow de 1):
Piso 01010100 (84) -> 00101000 (40) Techo: 10010110 (150) -> 10101101 (173)
Nuevos Intervalos:
C [151 – 173] ; B [107 - 150] ; A [40 - 106]
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 :
0011(Fijo)0(Descartado)0010111(leídos)
10010111 (151) -> Cae en el rango (es el piso) de la C
Se emite una C.
FIUBA
Organización de Datos - Curso Servetto
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.
Organización de Datos - Curso Servetto
85
Algoritmos de
Compresión No
estadística
Algoritmo Lz77
Algoritmo Lz78/W
FIUBA
Organización de Datos - Curso Servetto
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
Organización de Datos - Curso Servetto
87
Algoritmos de Compresión
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
Organización de Datos - Curso Servetto
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
Organización de Datos - Curso Servetto
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
Organización de Datos - Curso Servetto
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
Organización de Datos - Curso Servetto
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
Organización de Datos - Curso Servetto
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.
Organización de Datos - Curso Servetto
93
Algoritmo Lz77
(por Diccionario)
●
Ejemplo de Compresión fuente
RAPATAPATAPARAPAPA :
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|
Organización de Datos - Curso Servetto
94
Algoritmo Lz77
(por Diccionario)
●
●
Ejemplo de Compresión fuente
RAPATAPATAPARAPAPA :
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%
Organización de Datos - Curso Servetto
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.
Organización de Datos - Curso Servetto
96
Algoritmo Lz77
(por Diccionario)
●
Ejemplo de Descompresión fuente
RAPATAPATAPARAPAPA :
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)
Organización de Datos - Curso Servetto
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.
Organización de Datos - Curso Servetto
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
Organización de Datos - Curso Servetto
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
Organización de Datos - Curso Servetto
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
Organización de Datos - Curso Servetto
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
Organización de Datos - Curso Servetto
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
Organización de Datos - Curso Servetto
103
Referencias
●
FIUBA
Terry Welch, "A Technique for High-Performance
Data Compression", IEEE Computer, June 1984,
p. 8–19.
Organización de Datos - Curso Servetto
104
Algoritmos de
Compresión
Predictores
Algoritmo Aritmético de Orden mayor a 1
Algoritmo PPMC
FIUBA
Organización de Datos - Curso Servetto
105
Algoritmos de Compresión
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.
Organización de Datos - Curso Servetto
106
Algoritmos de Compresión
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.
Organización de Datos - Curso Servetto
107
Algoritmo Aritmético O(n)
(Predictor)
FIUBA
Organización de Datos - Curso Servetto
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
Organización de Datos - Curso Servetto
0001
0010
109
Algoritmos de Compresión
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
Organización de Datos - Curso Servetto
110
Algoritmos de Compresión
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
..
Organización de Datos - Curso Servetto
A
B
C
D
..
A
B
C
..
A
B
A
B
C
D
..
C
..
A
B
C
D
..
A
B
C
..
111
Algoritmo Aritmético
(Orden 1)
●
Compresión de ABACAB:
Compresión del caracter ‘A' - (Posicion: 0)
●
Contexto \b: A=1, B=1, C=1
Piso inicial: 0 - Techo Inicial 255 Intervalo: 256
N.Piso = 0 + 256 * 0 = 0 N. Techo = 0 + 256 * 1 / 3 - 1 = 84
Resultado de la normalización:
Piso: 00000000 (0) -> 00000000 (0) Techo: 01010100 (84) -> 10101001 (169)
Emisión: 0
C. underflow: 0
Compresión del caracter ‘B' - (Posicion: 1)
●
Contexto A: A=1, B=1, C=1  Contexto A: A=1, B=2, C=1
Piso inicial: 0 - Techo Inicial 169 Intervalo: 170
N.Piso = 0 + 170 * 1 / 3 = 56 N. Techo = 0 + 170 * 2 / 3 - 1 = 112
Resultado de la normalización:
Piso 00111000 (56) -> 01110000 (112) Techo: 01110000 (112) -> 11100001 (225)
Emisión: 0
C. underflow: 0
FIUBA
Organización de Datos - Curso Servetto
112
Algoritmo Aritmético
(Orden 1)
●
Compresión de ABACAB :
Compresión del caracter ‘A' - (Posicion: 2)
●
Contexto B: A=1, B=1, C=1  Contexto B: A=2, B=1, C=1
Piso inicial: 112 - Techo Inicial 225 Intervalo: 114
N.Piso = 112 + 114 * 0 / 3 = 112 N. Techo = 112 + 114 * 1 / 3 - 1 = 149
Resultado de la normalización:
Piso: 01110000 (112) -> 01000000 (64) Techo: 10010101 (149) -> 11010111 (215)
Emisión: 0
C. underflow: 2
Compresión del caracter ‘C' - (Posicion: 3)
●
Contexto A: A=1, B=2, C=1  Contexto A: A=1, B=2, C=2
Piso inicial: 64 - Techo Inicial 215 Intervalo: 152
N.Piso = 64 + 152 * 3 / 4 = 178 N. Techo = 64 + 152 * 4 / 4 - 1 = 215
Resultado de la normalización:
Piso: 10110010 (178) -> 01001000 (72) Techo: 11010111 (215) -> 11011111 (223)
Emisión: 100(Underflow)
C. underflow: 1
FIUBA
Organización de Datos - Curso Servetto
113
Algoritmo Aritmético
(Orden 1)
●
Compresión de ABACAB:
Compresión del caracter ‘A' - (Posicion: 4)
●
Contexto C: A=1, B=1, C=1  Contexto C: A=2, B=1, C=1
Piso inicial: 72 - Techo Inicial 223 Intervalo: 152
N.Piso = 72 + 152 * 0 / 3 = 72 N. Techo = 72 + 152 * 1 / 3 - 1 = 121
Resultado de la normalización:
Piso: 01001000 (72) -> 00100000 (32) Techo: 01111001 (121) -> 11100111 (231)
Emisión: 011(Underflow)
C. underflow: 0
Compresión del caracter ‘B' - (Posicion: 5)
●
Contexto A: A=1, B=2, C=2  Contexto A: A=1, B=3, C=2
Piso inicial: 32 - Techo Inicial 231 Intervalo: 200
N.Piso = 32 + 200 * 1 / 5 = 72 N. Techo = 32 + 200 * 3 / 5 - 1 = 151
Al ser el ultimo caracter, se emite el piso, incluyendo los underflows: Piso: 01001000 (72) --- > Emisión: 01001000
Emision final:0-0-100-011-01001000
FIUBA
Organización de Datos - Curso Servetto
114
Algoritmo Aritmético
(Orden 1)
●
Descompresión de ABACAB:
Descompresión del caracter ‘A‘
●
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.
●
Descompresión del caracter ‘B‘
●
Contexto A: A=1, B=1, C=1  Contexto A: A=1, B=2, C=1
Se plantea el nuevo intervalo(0-84)(Overflow de 0)
Resultado de la normalización(Overflow de 0):
Piso: 00000000 (0) -> 00000000 (0) Techo: 01010100 (84) -> 10101001 (169)
Nuevos Intervalos:
C [113 – 169]; B [55 – 112] ; A [000 - 55]
Debido al overflow, descartamos el 1er bit leído anteriormente y leemos uno mas del archivo: 001000111
01000111 (71) -> Cae en el rango de la B
Se emite una B.
FIUBA
Organización de Datos - Curso Servetto
115
Algoritmo Aritmético
(Orden 1)
●
Descompresión de ABACAB:
Descompresión del caracter ‘A‘
●
Contexto B: A=1, B=1, C=1  Contexto B: A=2, B=1, C=1
Se plantea el nuevo intervalo(56-169)(Overflow de 0)
Resultado de la normalización(Overflow de 0):
Piso 00111000 (56) -> 01110000 (112) Techo: 01110000 (112) -> 11100001 (225)
C [188 - 225]; B [150 - 187]; A [112 - 149] = [01110000 - 10010101]
Debido al overflow, descartamos el 1er bit leído anteriormente y leemos uno mas del archivo: 0010001101
10001110 (142) -> Cae en el rango de la A
Se emite una A.
Descompresión del caracter ‘C‘
●
Contexto A: A=1, B=2, C=1  Contexto A: A=1, B=2, C=2
Se plantea el nuevo intervalo(112-149)(Underflow de 2)
Resultado de la normalización(Underflow de 2):
Piso 01110000 (112) -> 01000000 (64) Techo: 10010101 (149) -> 110101111 (215)
Nuevos Intervalos:
C [178 - 215] ; B [102 – 177]; A [64 - 101]
Debido al Underflow, dejamos fijo el 1er bit en inspección y luego descartar tantos bits como underflows tengamos(2 bit en este caso, 0),
completar del archivo leyendo los bits necesarios para 1 byte :
001(Fijo)00(Descartados)0110100(leídos)
10110100 (180) -> Cae en el rango de la C
Se emite una C.
FIUBA
Organización de Datos - Curso Servetto
116
Algoritmo Aritmético
(Orden 1)
●
Descompresión de ABACAB:
Descompresión del caracter ‘A‘
●
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.
Debido al Underflow, dejamos fijo el 1er bit en inspección y luego descartar tantos bits como underflows tengamos(1 bit en este caso, 1),
completar del archivo leyendo los bits necesarios para 1 byte :
01010010 (82) -> Cae en el rango de la A
001(Descartado)000(Fijo)1(Descartado)1010010(leídos)
Se emite una A.
Descompresión del caracter ‘B‘
●
Contexto A: A=1, B=2, C=2  Contexto A: A=1, B=3, C=2
Se plantea el nuevo intervalo(72-121)(Overflow de 2)
Resultado de la normalización(Overflow de 2):
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.
Organización de Datos - Curso Servetto
117
Referencias
●
FIUBA
Gordon Cormack and Nigel Horspool, "Data
Compression using Dynamic Markov Modelling",
Computer Journal 30:6 (December 1987)
Organización de Datos - Curso Servetto
118
Algoritmo PPMC
(Prediction by Partial
Matching Mode C)
FIUBA
Organización de Datos - Curso Servetto
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
Organización de Datos - Curso Servetto
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
Organización de Datos - Curso Servetto
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
Organización de Datos - Curso Servetto
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
Organización de Datos - Curso Servetto
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
Organización de Datos - Curso Servetto
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
Organización de Datos - Curso Servetto
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
Organización de Datos - Curso Servetto
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
Organización de Datos - Curso Servetto
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)
Organización de Datos - Curso Servetto
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
Organización de Datos - Curso Servetto
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)
Organización de Datos - Curso Servetto
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
Organización de Datos - Curso Servetto
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)
-
Organización de Datos - Curso Servetto
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”)
Organización de Datos - Curso Servetto
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
Organización de Datos - Curso Servetto
134
Algoritmos de
Compresión
Híbridos
FIUBA
Organización de Datos - Curso Servetto
135
Half Coding
FIUBA
Organización de Datos - Curso Servetto
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
Organización de Datos - Curso Servetto
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
Organización de Datos - Curso Servetto
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
Organización de Datos - Curso Servetto
139
LZHuff
FIUBA
Organización de Datos - Curso Servetto
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
Organización de Datos - Curso Servetto
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
Organización de Datos - Curso Servetto
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
Organización de Datos - Curso Servetto
143
LZP
FIUBA
Organización de Datos - Curso Servetto
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
Organización de Datos - Curso Servetto
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
Organización de Datos - Curso Servetto
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
Organización de Datos - Curso Servetto
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
Organización de Datos - Curso Servetto
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
Organización de Datos - Curso Servetto
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)
Organización de Datos - Curso Servetto
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
Piso inicial: 0 - Techo Inicial 255 Intervalo: 256
N.Piso = 0 + 256 * 0 = 0 N. Techo = 0 + 256 * 1 / 5 - 1 = 50
Resultado de la normalización:
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
Piso inicial: 0 - Techo Inicial 203 Intervalo: 204
N.Piso = 0 + 204 * 0 / 7 = 0 N. Techo = 0 + 204 * 1 / 7 - 1 = 28
Resultado de la normalización:
Piso 00000000 (0) -> 00000000 (0) Techo: 00011100 (28) -> 11100111 (231)
Emisión: 000
C. underflow: 0
FIUBA
Organización de Datos - Curso Servetto
151
LZP
●
Compresión de AAAAAANTANANARIVO:
Compresión de Longitud 0:
●
L0=2, L1=1, L2=1 , L3=1 , L4=1  L0=3, L1=1, L2=1 , L3=1 , L4=1
Piso inicial: 0 - Techo Inicial 231 Intervalo: 232
N.Piso = 0 + 232 * 0 = 0 N. Techo = 0 + 232 * 2 / 6 - 1 = 76
Resultado de la normalización:
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
Piso inicial: 0 - Techo Inicial 153 Intervalo: 154
N.Piso = 0 + 154 * 0 / 7 = 0 N. Techo = 0 + 154 * 1 / 7 - 1 = 21
Resultado de la normalización:
Piso 00000000 (0) -> 00000000 (0) Techo: 00010101 (21) -> 10101111 (175)
Emisión: 000
C. underflow: 0
FIUBA
Organización de Datos - Curso Servetto
152
LZP
●
Compresión de AAAAAANTANANARIVO:
Compresión de Longitud 0:
●
L0=3, L1=1, L2=1 , L3=1 , L4=1  L0=4, L1=1, L2=1 , L3=1 , L4=1
Piso inicial: 0 - Techo Inicial 175 Intervalo: 176
N.Piso = 0 + 176 * 0 = 0 N. Techo = 0 + 176 * 3 / 7 - 1 = 74
Resultado de la normalización:
Piso: 00000000 (0) -> 00000000 (0) Techo: 01001010 (74) -> 10010101 (149)
Emisión: 0
C. underflow: 0
Compresión del caracter ‘A' – Contexto A
●
Contexto A: A=2, I=1, N=1, O=1, V=1, R=1, EOF=1  Contexto A: A=3, I=1, N=1, O=1, V=1, R=1, EOF=1
Piso inicial: 0 - Techo Inicial 149 Intervalo: 150
N.Piso = 0 + 150 * 0 / 8 = 0 N. Techo = 0 + 150 * 2 / 8 - 1 = 36
Resultado de la normalización:
Piso 00000000 (0) -> 00000000 (0) Techo: 00100100 (36) -> 10010011 (147)
Emisión: 00
C. underflow: 0
FIUBA
Organización de Datos - Curso Servetto
153
LZP
●
Compresión de AAAAAANTANANARIVO:
Compresión de Longitud 3:
●
L0=4, L1=1, L2=1 , L3=1 , L4=1  L0=4, L1=1, L2=1 , L3=2 , L4=1
Piso inicial: 0 - Techo Inicial 147 Intervalo: 148
N.Piso = 0 + 148 * 6 / 8 = 111 N. Techo = 0 + 148 * 7 / 8 - 1 = 128
Resultado de la normalización:
Piso: 01101111 (111) -> 00111100 (60) Techo: 10000000 (128) -> 10000011 (131)
Emisión:
C. underflow: 2
Compresión del caracter ‘N' – Contexto A
●
Contexto A: A=3, I=1, N=1, O=1, V=1, R=1, EOF=1  Contexto A: A=3, I=1, N=2, O=1, V=1, R=1, EOF=1
Piso inicial: 60 - Techo Inicial 131 Intervalo: 72
N.Piso = 60 + 72 * 4 / 9 = 92 N. Techo = 60 + 72 * 5 / 9 - 1 = 99
Resultado de la normalización:
Piso 01011100 (92) -> 00000000 (0) Techo: 01100011 (99) -> 11111111 (255)
Emisión: 0111
C. underflow: 3
FIUBA
Organización de Datos - Curso Servetto
154
Técnicas de
Optimización de la
Compresión
FIUBA
Organización de Datos - Curso Servetto
155
Block Sorting
FIUBA
Organización de Datos - Curso Servetto
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
Organización de Datos - Curso Servetto
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
Organización de Datos - Curso Servetto
158
Block Sorting
Fuente: SALALALASARAS
FIUBA
Organización de Datos - Curso Servetto
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
Organización de Datos - Curso Servetto
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
Organización de Datos - Curso Servetto
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
Organización de Datos - Curso Servetto
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
Organización de Datos - Curso Servetto
163
Move To Front
FIUBA
Organización de Datos - Curso Servetto
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
Organización de Datos - Curso Servetto
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
Organización de Datos - Curso Servetto
167
Move To Front
SALALALASARAS, luego del BS se
transforma en SLLSRAAAASAA-10
FIUBA
Organización de Datos - Curso Servetto
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
Organización de Datos - Curso Servetto
169
Modelo de Shannon
FIUBA
Organización de Datos - Curso Servetto
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
Organización de Datos - Curso Servetto
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 3 matchea con el símbolo 2
• El modelo 4 matchea con el símbolo 3
• El modelo 5 matchea con el resto de los
símbolos
FIUBA
Organización de Datos - Curso Servetto
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
Organización de Datos - Curso Servetto
173
Modelo de Shannon
FIUBA
Organización de Datos - Curso Servetto
174
Modelo Estructurado
FIUBA
Organización de Datos - Curso Servetto
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
Organización de Datos - Curso Servetto
176
Modelo Estructurado
• Siempre se empieza del modelo 0
• Matches:
FIUBA
Organización de Datos - Curso Servetto
177
Modelo Estructurado
FIUBA
Organización de Datos - Curso Servetto
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
Organización de Datos - Curso Servetto
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
Organización de Datos - Curso Servetto
180
Algoritmos de
Compresión Con
Pérdida
(Lossy)
Compactación de imágenes: JPEG
Compactación de vídeo: MPEG
FIUBA
Organización de Datos - Curso Servetto
181
Algoritmos de Compresión
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
Organización de Datos - Curso Servetto
182
Algoritmos de Compresión
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
Organización de Datos - Curso Servetto
183
Algoritmos de Compresión
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
Organización de Datos - Curso Servetto
184
Algoritmos de Compresión
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
Organización de Datos - Curso Servetto
185
JPEG
FIUBA
Organización de Datos - Curso Servetto
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
Organización de Datos - Curso Servetto
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
Organización de Datos - Curso Servetto
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
Organización de Datos - Curso Servetto
189
JPEG (codificación)
• 1er paso: Preparación de los bloques
• 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
Organización de Datos - Curso Servetto
190
JPEG (codificación)
• 1er paso: Preparación de los bloques
• 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
Organización de Datos - Curso Servetto
191
JPEG (codificación)
• 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
Organización de Datos - Curso Servetto
192
JPEG (codificación)
• 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
Organización de Datos - Curso Servetto
193
JPEG (codificación)
• 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
Organización de Datos - Curso Servetto
194
JPEG (codificación)
• 3er paso: Cuantización
FIUBA
Organización de Datos - Curso Servetto
195
JPEG (codificación)
• 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
Organización de Datos - Curso Servetto
196
JPEG (codificación)
• 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
Organización de Datos - Curso Servetto
197
JPEG (codificación)
• 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
Organización de Datos - Curso Servetto
198
MPEG
FIUBA
Organización de Datos - Curso Servetto
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
Organización de Datos - Curso Servetto
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
Organización de Datos - Curso Servetto
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
Organización de Datos - Curso Servetto
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
Organización de Datos - Curso Servetto
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
Organización de Datos - Curso Servetto
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
Organización de Datos - Curso Servetto
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
Organización de Datos - Curso Servetto
206
Referencias
●
FIUBA
A. S. Tanenbaum, "Sistemas Operativos
Modernos, Segunda Edición", Prentice Hall.
ISBN 0-13-031358-0, 976 páginas.
Organización de Datos - Curso Servetto
207