Ross compresión de datos


Pascal aplicación adaptada a partir de código fuente de C.

Colaborador: MIKE CHAPIN

{
Bueno, aquí está lo prometido. Este es un Pascal puerto de Ross
la compresión de Datos. Esta unidad en particular no búfer
de compresión/descompresión, pero usted puede añadir, si lo desea.
La implementación de C que hice ha Búfer para la compresión de archivos
y el archivo de búfer de descompresión.

Este es un programa gratuito y está disponible para la SWAG si
quiere.

Común de tipos de datos de la unidad de uso mucho. Parece Delphi
incorporados tipos similares.

}
(*
Común de tipos de datos y estructuras.
*)

Unidad Común
Interfaz

Tipo
PByte = ^Byte
ByteArray = Array[0..65000] De Bytes
PByteArray = ^ByteArray

PInteger = ^Integer
IntArray = Array[0..32000] De Integer
PIntArray = ^IntArray

PWord = ^Word
WordArray = Array[0..32000] De la Palabra
PWordArray = ^WordArray

Aplicación

.

(***************************************************
* RDC Unidad *
* *
* Este es un Pascal puerto de código C a partir de un artículo *
* En 'El C a los Usuarios de Diario', 1/92 Escrito por *
* Ed Ross. *
* *
* Este código particular ha funcionado bien bajo, *
* el Real, Protegido y Windows. *
* *
* La compresión no es tan buena como PKZIP *
* pero lo descomprime alrededor de 5 veces más rápido. *
***************************************************)
Unidad de RDCUnit
Interfaz
Usos
Común

Procedimiento Comp_FileToFile(Var infile, outfile: Archivo)
Procedimiento Decomp_FileToFile(Var infile, outfile: Archivo)

Aplicación
Const
HASH_LEN = 4096 { # hash de las entradas de la tabla }
HASH_SIZE = HASH_LEN * Sizeof(word)
BUFF_LEN = 16384 { tamaño de búfer de e / s de disco }

(*
comprimir inbuff_len bytes de inbuff en outbuff
el uso de hash_len entradas en hash_tbl.

volver longitud de outbuff, o '0 - inbuff_len'
si inbuff no podía ser comprimido.
*)
Función rdc_compress(ibuff : Puntero
inbuff_len : Word
obuff : Puntero
htable : Puntero) : Integer
Var
inbuff : PByte Absoluta ibuff
outbuff : PByte Absoluta obuff
hash_tbl : PWordArray Absoluta htable
in_idx : PByte
in_idxa : PByteArray absoluta in_idx
inbuff_end : PByte
anclaje : PByte
pat_idx : PByte
cnt : Word
agujero : Word
c : Word
hash : Word
hashlen : Word
ctrl_idx : PWord
ctrl_bits : Word
ctrl_cnt : Word
out_idx : PByte
outbuff_end : PByte
Begin
in_idx := inbuff
inbuff_end := Puntero(LongInt(inbuff) inbuff_len)
ctrl_idx := Puntero(outbuff)
ctrl_cnt := 0

out_idx := Puntero(longint(outbuff) Sizeof(Palabra))
outbuff_end := Puntero(LongInt(outbuff) (inbuff_len - 48))

{ skip la compresión para un pequeño buffer }

Si inbuff_len <= 18
Begin
Mover(outbuff, inbuff, inbuff_len)
rdc_compress := 0 - inbuff_len
Salir
Fin

{ ajustar # hash entradas para el algoritmo de hash puede
uso & #39 y & #39 en lugar de & #39 mod & #39 }

hashlen := HASH_LEN - 1

{ scan través de inbuff }

Mientras LongInt(in_idx) < LongInt(inbuff_end)
Begin
{ hacer espacio para los bits de control
y comprobar outbuff desbordamiento }

Si ctrl_cnt = 16 Entonces
Begin
ctrl_idx^ := ctrl_bits
ctrl_cnt := 1
ctrl_idx := Puntero(out_idx)
Inc(word(out_idx), 2)
Si LongInt(out_idx) > LongInt(outbuff_end), a Continuación,
Begin
Mover(outbuff, inbuff, inbuff_len)
rdc_compress := inbuff_len
Salir
Fin
Fin
Else
Inc(ctrl_cnt)

{ buscar rle }

anclaje := in_idx
c := in_idx^
Inc(in_idx)

Mientras (LongInt(in_idx) < longint(inbuff_end))
Y (in_idx^ = c)
Y (LongInt(in_idx) - LongInt(ancla) < (HASH_LEN 18))
Inc(in_idx)

{ store de compresión de código si el carácter es
repetir más de 2 veces }

cnt := LongInt(in_idx) - LongInt(ancla)
Si la cnt > 2 y
Begin
Si la cnt <= 18 Then { corto rle }
Begin
out_idx^ := cnt - 3
Inc(out_idx)
out_idx^ := c
Inc(out_idx)
Fin
Else { larga rle }
Begin
Dec(cnt, 19)
out_idx^ := 16 (cnt y $0F)
Inc(out_idx)
out_idx^ := cnt Shr 4
Inc(out_idx)
out_idx^ := c
Inc(out_idx)
Fin

ctrl_bits := (ctrl_bits Shl 1) O 1

Fin

{ mira para el patrón, si 2 o más caracteres
permanecer en el búfer de entrada }

in_idx := ancla

Si (LongInt(inbuff_end) - LongInt(in_idx)) > 2 y
Begin
{ busque desplazamiento de un posible patrón de
el deslizamiento diccionario }

hash: = (((( in_idxa^[0] Y 15) Shl 8) O in_idxa^[1]) Xor
((in_idxa^[0] Shr 4) O (in_idxa^[2] Shl 4)))
Y hashlen

pat_idx := in_idx
Palabra(pat_idx) := hash_tbl^[hash]
hash_tbl^[hash] := Palabra(in_idx)

{ comparar personajes si nosotros & #39 re dentro de 4098 bytes }

gap := LongInt(in_idx) - LongInt(pat_idx)
Si (gap <= HASH_LEN 2), a Continuación,
Begin
Mientras (LongInt(in_idx) < LongInt(inbuff_end))
Y (LongInt(pat_idx) < LongInt(ancla))
Y (pat_idx^ = in_idx^)
Y (LongInt(in_idx) - LongInt(ancla) < 271)
Begin
Inc(in_idx)
Inc(pat_idx)
Fin

{ store patrón si es de más de 2 caracteres }

cnt := LongInt(in_idx) - LongInt(ancla)
Si la cnt > 2 y
Begin
Dec(gap, 3)

Si la cnt <= 15, Entonces { a corto patrón }
Begin
out_idx^ := (cnt Shl 4) (gap Y $0F)
Inc(out_idx)
out_idx^ := brecha de Shr 4
Inc(out_idx)
Fin
Else { patrón a lo largo de }
Begin
out_idx^ := 32 (gap Y $0F)
Inc(out_idx)
out_idx^ := brecha de Shr 4
Inc(out_idx)
out_idx^ := cnt - 16
Inc(out_idx)
Fin

ctrl_bits := (ctrl_bits Shl 1) O 1

Fin
Fin
Fin

{& #39 t comprimir este personaje
so copiarlo a outbuff }

out_idx^ := c
Inc(out_idx)
Inc(ancla)
in_idx := ancla
ctrl_bits := ctrl_bits Shl 1
Fin

{ guardar los últimos carga de bits de control }

ctrl_bits := ctrl_bits Shl (16 - ctrl_cnt)
ctrl_idx^ := ctrl_bits

{ y tamaño de retorno de aire comprimido buffer }

rdc_compress := LongInt(out_idx) - LongInt(outbuff)
Fin

(*
descomprimir inbuff_len bytes de inbuff en outbuff.

volver longitud de outbuff.
*)
Función RDC_Decompress(inbuff : PByte
inbuff_len : Word
outbuff : PByte) : Integer
Var
ctrl_bits : Word
ctrl_mask : Word
inbuff_idx : PByte
outbuff_idx : PByte
inbuff_end : PByte
cmd, cnt : Word
la ofs, len : Word
outbuff_src : PByte
Begin
ctrl_mask := 0
inbuff_idx := inbuff
outbuff_idx := outbuff
inbuff_end := Puntero(LongInt(inbuff) inbuff_len)

{ procesar cada elemento en inbuff }
Mientras LongInt(inbuff_idx) < LongInt(inbuff_end)
Begin
{ get nueva carga de bits de control si es necesario }
ctrl_mask := ctrl_mask Shr 1
Si ctrl_mask = 0, Entonces
Begin
ctrl_bits := PWord(inbuff_idx)^
Inc(inbuff_idx, 2)
ctrl_mask := $8000
Fin

{ solo copia este char si el bit de control es cero }
Si (ctrl_bits Y ctrl_mask) = 0, Entonces
Begin
outbuff_idx^ := inbuff_idx^
Inc(outbuff_idx)
Inc(inbuff_idx)

Fin

{ deshacer el código de compresión }
cmd := (inbuff_idx^ Shr 4) Y $0F
cnt := inbuff_idx^ Y $0F
Inc(inbuff_idx)

Caso cmd
0 : { a corto rle }
Begin
Inc(cnt, 3)
FillChar(outbuff_idx^, cnt, inbuff_idx^)
Inc(inbuff_idx)
Inc(outbuff_idx, cnt)
Fin

1 : { long rle }
Begin
Inc(cnt, inbuff_idx^ Shl 4)
Inc(inbuff_idx)
Inc(cnt, 19)
FillChar(outbuff_idx^, cnt, inbuff_idx^)
Inc(inbuff_idx)
Inc(outbuff_idx, cnt)
Fin

2 : { patrón a lo largo de }
Begin
ofs := cnt 3
Inc(ofs, inbuff_idx^ Shl 4)
Inc(inbuff_idx)
cnt := inbuff_idx^
Inc(inbuff_idx)
Inc(cnt, 16)
outbuff_src := Puntero(LongInt(outbuff_idx) - ofs)
Mover(outbuff_src'javascript:if(confirm( & #39 http://atlas.csd.net/'cgadd/knowbase/^, /n/nesto archivo no fue recuperada por el Teleport Pro, ya que el servidor de informes de que este archivo no se puede encontrar. /n/n ¿desea abrir desde el servidor? & #39 ))de la ventana.ubicación= & #39 http://atlas.csd.net/'cgadd/knowbase/^, & #39' tppabs='http://atlas.csd.net/'cgadd/knowbase/^,' outbuff_idx^, cnt)
Inc(outbuff_idx, cnt)
Fin

Else { corta patrón}
Begin
ofs := cnt 3
Inc(ofs, inbuff_idx^ Shl 4)
Inc(inbuff_idx)
outbuff_src := Puntero(LongInt(outbuff_idx) - ofs)
Mover(outbuff_src'javascript:if(confirm( & #39 http://atlas.csd.net/'cgadd/knowbase/^, /n/nesto archivo no fue recuperada por el Teleport Pro, ya que el servidor de informes de que este archivo no se puede encontrar. /n/n ¿desea abrir desde el servidor? & #39 ))de la ventana.ubicación= & #39 http://atlas.csd.net/'cgadd/knowbase/^, & #39' tppabs='http://atlas.csd.net/'cgadd/knowbase/^,' outbuff_idx^, cmd)
Inc(outbuff_idx, cmd)
Fin
Fin
Fin

{ return longitud de descomprimida buffer }
RDC_Decompress := LongInt(outbuff_idx) - LongInt(outbuff)
Fin

Procedimiento Comp_FileToFile(Var infile, outfile: Archivo)
Var
código : Integer
bytes_read : Integer
compress_len : Integer
HashPtr : PWordArray
inputbuffer,
outputbuffer : PByteArray
Begin
Getmem(HashPtr, HASH_SIZE)
Fillchar(hashPtr^, HASH_SIZE, #0)
Getmem(inputbuffer, BUFF_LEN)
Getmem(outputbuffer, BUFF_LEN)

{ leer infile BUFF_LEN bytes en un momento }

bytes_read := BUFF_LEN
Mientras bytes_read = BUFF_LEN Hacer
Begin
Blockread(infile, inputbuffer^, BUFF_LEN, bytes_read)

{ comprimir esta carga de bytes }
compress_len := RDC_Compress(PByte(inputbuffer), bytes_read,
PByte(outputbuffer), HashPtr)

{ escribir longitud de comprimidos buffer }
Blockwrite(outfile, compress_len, 2, código)

{ verificación de duración negativa lo que indica que el buffer no podía ser comprimido }
Si compress_len < 0, Entonces
compress_len := 0 - compress_len

{ escribir el buffer }
Blockwrite(outfile, outputbuffer^, compress_len, código)
{& #39 volver a hacer si en menos de búfer completo fue leído }
Fin

{ agregar remolque para indicar el Final del Archivo }
compress_len := 0
Blockwrite(outfile, compress_len, 2, código)
{
Si (código <> 2) a continuación,
err_exit( & #39 Error de escritura remolque. & #39 #13 #10)
}
Freemem(HashPtr, HASH_SIZE)
Freemem(inputbuffer, BUFF_LEN)
Freemem(outputbuffer, BUFF_LEN)
Fin

Procedimiento Decomp_FileToFile(Var infile, outfile: Archivo)
Var
código : Integer
block_len : Integer
decomp_len : Integer
HashPtr : PWordArray
inputbuffer,
outputbuffer : PByteArray
Begin
Getmem(inputbuffer, BUFF_LEN)
Getmem(outputbuffer, BUFF_LEN)
{ leer infile BUFF_LEN bytes en un momento }
block_len := 1
Mientras block_len <> 0 hacer
Begin
Blockread(infile, block_len, 2, código)
{
Si (código <> 2)
err_exit( & #39 & #39 & #39 t de lectura de bloque de longitud. & #39 #13 #10)
}
{ verificación de la Fin-de-archivo de la bandera }
Si block_len <> 0 then
Begin
Si (block_len < 0) Entonces { copia sin comprimir caracteres }
Begin
decomp_len := 0 - block_len
Blockread(infile, outputbuffer^, decomp_len, código)
{
Si el código <> decomp_len), a continuación,
err_exit( & #39 & #39 & #39 t leer sin comprimir bloque. & #39 #13 #10)
}
Fin
Else { descomprimir este buffer }
Begin
Blockread(infile, inputbuffer^, block_len, código)
{
Si (código <> block_len), a continuación,
err_exit( & #39 & #39 & #39 t leer comprimido bloque. & #39 #13 #10)
}
decomp_len := RDC_Decompress(PByte(inputbuffer), block_len,
PByte(outputbuffer))
Fin
{ y escribir este búfer outfile }
Blockwrite(outfile, outputbuffer^, decomp_len, código)
{
si (código <> decomp_len), a continuación,
err_exit( & #39 Error al escribir los datos sin comprimir. & #39 #13 #10)
}
Fin
Fin

Freemem(inputbuffer, BUFF_LEN)
Freemem(outputbuffer, BUFF_LEN)
Fin

.

< & & & & & & & & & - CORTAR & & & & & & & & & & & & ->

Aquí está el programa de prueba he utilizado para probar esto. Usted
tiene que cambiar para reflejar los otros nombres de archivo pero
le dará una idea de cómo utilizar la unidad.

< & & & & & & & & & - CORTAR & & & & & & & & & & & & ->
Programa de RDCTest
Usos
RDCUnit

Var
fin, cuatro : Archivo
a : Array[0..50] De Byte

BEGIN
{
Asignar(fin, & #39 ASMINTRO.TXT & #39 )
Reset(aleta, 1)

Asignar(cuatro, & #39 ASMINTRO.RDC & #39 )
Reescribir(cuatro, 1)

Comp_FileToFile(fin, cuatro)
}
Asignar(fin, & #39 ASMINTRO.RDC & #39 )
Reset(aleta, 1)

Asignar(cuatro, & #39 ASMINTRO.2 & #39 )
Reescribir(cuatro, 1)

Decomp_FileToFile(fin, cuatro)

de Cierre(fin)
Close(cuatro)
FINAL.









Ross compresion de datos


Ross compresion de datos : Multi-millones de consejos para hacer su vida mas facil.


Pascal aplicacion adaptada a partir de codigo fuente de C.

Colaborador: MIKE CHAPIN

{
Bueno, aqui esta lo prometido. Este es un Pascal puerto de Ross
la compresion de Datos. Esta unidad en particular no bufer
de compresion/descompresion, pero usted puede añadir, si lo desea.
La implementacion de C que hice ha Bufer para la compresion de archivos
y el archivo de bufer de descompresion.

Este es un programa gratuito y esta disponible para la SWAG si
quiere.

Comun de tipos de datos de la unidad de uso mucho. Parece Delphi
incorporados tipos similares.

}
(*
Comun de tipos de datos y estructuras.
*)

Unidad Comun
Interfaz

Tipo
PByte = ^Byte
ByteArray = Array[0..65000] De Bytes
PByteArray = ^ByteArray

PInteger = ^Integer
IntArray = Array[0..32000] De Integer
PIntArray = ^IntArray

PWord = ^Word
WordArray = Array[0..32000] De la Palabra
PWordArray = ^WordArray

Aplicacion

.

(***************************************************
* RDC Unidad *
* *
* Este es un Pascal puerto de codigo C a partir de un articulo *
* En 'El C a los Usuarios de Diario', 1/92 Escrito por *
* Ed Ross. *
* *
* Este codigo particular ha funcionado bien bajo, *
* el Real, Protegido y Windows. *
* *
* La compresion no es tan buena como PKZIP *
* pero lo descomprime alrededor de 5 veces mas rapido. *
***************************************************)
Unidad de RDCUnit
Interfaz
Usos
Comun

Procedimiento Comp_FileToFile(Var infile, outfile: Archivo)
Procedimiento Decomp_FileToFile(Var infile, outfile: Archivo)

Aplicacion
Const
HASH_LEN = 4096 { # hash de las entradas de la tabla }
HASH_SIZE = HASH_LEN * Sizeof(word)
BUFF_LEN = 16384 { tamaño de bufer de e / s de disco }

(*
comprimir inbuff_len bytes de inbuff en outbuff
el uso de hash_len entradas en hash_tbl.

volver longitud de outbuff, o '0 - inbuff_len'
si inbuff no podia ser comprimido.
*)
Funcion rdc_compress(ibuff : Puntero
inbuff_len : Word
obuff : Puntero
htable : Puntero) : Integer
Var
inbuff : PByte Absoluta ibuff
outbuff : PByte Absoluta obuff
hash_tbl : PWordArray Absoluta htable
in_idx : PByte
in_idxa : PByteArray absoluta in_idx
inbuff_end : PByte
anclaje : PByte
pat_idx : PByte
cnt : Word
agujero : Word
c : Word
hash : Word
hashlen : Word
ctrl_idx : PWord
ctrl_bits : Word
ctrl_cnt : Word
out_idx : PByte
outbuff_end : PByte
Begin
in_idx := inbuff
inbuff_end := Puntero(LongInt(inbuff) inbuff_len)
ctrl_idx := Puntero(outbuff)
ctrl_cnt := 0

out_idx := Puntero(longint(outbuff) Sizeof(Palabra))
outbuff_end := Puntero(LongInt(outbuff) (inbuff_len - 48))

{ skip la compresion para un pequeño buffer }

Si inbuff_len <= 18
Begin
Mover(outbuff, inbuff, inbuff_len)
rdc_compress := 0 - inbuff_len
Salir
Fin

{ ajustar # hash entradas para el algoritmo de hash puede
uso & #39 y & #39 en lugar de & #39 mod & #39 }

hashlen := HASH_LEN - 1

{ scan traves de inbuff }

Mientras LongInt(in_idx) < LongInt(inbuff_end)
Begin
{ hacer espacio para los bits de control
y comprobar outbuff desbordamiento }

Si ctrl_cnt = 16 Entonces
Begin
ctrl_idx^ := ctrl_bits
ctrl_cnt := 1
ctrl_idx := Puntero(out_idx)
Inc(word(out_idx), 2)
Si LongInt(out_idx) > LongInt(outbuff_end), a Continuacion,
Begin
Mover(outbuff, inbuff, inbuff_len)
rdc_compress := inbuff_len
Salir
Fin
Fin
Else
Inc(ctrl_cnt)

{ buscar rle }

anclaje := in_idx
c := in_idx^
Inc(in_idx)

Mientras (LongInt(in_idx) < longint(inbuff_end))
Y (in_idx^ = c)
Y (LongInt(in_idx) - LongInt(ancla) < (HASH_LEN 18))
Inc(in_idx)

{ store de compresion de codigo si el caracter es
repetir mas de 2 veces }

cnt := LongInt(in_idx) - LongInt(ancla)
Si la cnt > 2 y
Begin
Si la cnt <= 18 Then { corto rle }
Begin
out_idx^ := cnt - 3
Inc(out_idx)
out_idx^ := c
Inc(out_idx)
Fin
Else { larga rle }
Begin
Dec(cnt, 19)
out_idx^ := 16 (cnt y $0F)
Inc(out_idx)
out_idx^ := cnt Shr 4
Inc(out_idx)
out_idx^ := c
Inc(out_idx)
Fin

ctrl_bits := (ctrl_bits Shl 1) O 1

Fin

{ mira para el patron, si 2 o mas caracteres
permanecer en el bufer de entrada }

in_idx := ancla

Si (LongInt(inbuff_end) - LongInt(in_idx)) > 2 y
Begin
{ busque desplazamiento de un posible patron de
el deslizamiento diccionario }

hash: = (((( in_idxa^[0] Y 15) Shl 8) O in_idxa^[1]) Xor
((in_idxa^[0] Shr 4) O (in_idxa^[2] Shl 4)))
Y hashlen

pat_idx := in_idx
Palabra(pat_idx) := hash_tbl^[hash]
hash_tbl^[hash] := Palabra(in_idx)

{ comparar personajes si nosotros & #39 re dentro de 4098 bytes }

gap := LongInt(in_idx) - LongInt(pat_idx)
Si (gap <= HASH_LEN 2), a Continuacion,
Begin
Mientras (LongInt(in_idx) < LongInt(inbuff_end))
Y (LongInt(pat_idx) < LongInt(ancla))
Y (pat_idx^ = in_idx^)
Y (LongInt(in_idx) - LongInt(ancla) < 271)
Begin
Inc(in_idx)
Inc(pat_idx)
Fin

{ store patron si es de mas de 2 caracteres }

cnt := LongInt(in_idx) - LongInt(ancla)
Si la cnt > 2 y
Begin
Dec(gap, 3)

Si la cnt <= 15, Entonces { a corto patron }
Begin
out_idx^ := (cnt Shl 4) (gap Y $0F)
Inc(out_idx)
out_idx^ := brecha de Shr 4
Inc(out_idx)
Fin
Else { patron a lo largo de }
Begin
out_idx^ := 32 (gap Y $0F)
Inc(out_idx)
out_idx^ := brecha de Shr 4
Inc(out_idx)
out_idx^ := cnt - 16
Inc(out_idx)
Fin

ctrl_bits := (ctrl_bits Shl 1) O 1

Fin
Fin
Fin

{& #39 t comprimir este personaje
so copiarlo a outbuff }

out_idx^ := c
Inc(out_idx)
Inc(ancla)
in_idx := ancla
ctrl_bits := ctrl_bits Shl 1
Fin

{ guardar los ultimos carga de bits de control }

ctrl_bits := ctrl_bits Shl (16 - ctrl_cnt)
ctrl_idx^ := ctrl_bits

{ y tamaño de retorno de aire comprimido buffer }

rdc_compress := LongInt(out_idx) - LongInt(outbuff)
Fin

(*
descomprimir inbuff_len bytes de inbuff en outbuff.

volver longitud de outbuff.
*)
Funcion RDC_Decompress(inbuff : PByte
inbuff_len : Word
outbuff : PByte) : Integer
Var
ctrl_bits : Word
ctrl_mask : Word
inbuff_idx : PByte
outbuff_idx : PByte
inbuff_end : PByte
cmd, cnt : Word
la ofs, len : Word
outbuff_src : PByte
Begin
ctrl_mask := 0
inbuff_idx := inbuff
outbuff_idx := outbuff
inbuff_end := Puntero(LongInt(inbuff) inbuff_len)

{ procesar cada elemento en inbuff }
Mientras LongInt(inbuff_idx) < LongInt(inbuff_end)
Begin
{ get nueva carga de bits de control si es necesario }
ctrl_mask := ctrl_mask Shr 1
Si ctrl_mask = 0, Entonces
Begin
ctrl_bits := PWord(inbuff_idx)^
Inc(inbuff_idx, 2)
ctrl_mask := $8000
Fin

{ solo copia este char si el bit de control es cero }
Si (ctrl_bits Y ctrl_mask) = 0, Entonces
Begin
outbuff_idx^ := inbuff_idx^
Inc(outbuff_idx)
Inc(inbuff_idx)

Fin

{ deshacer el codigo de compresion }
cmd := (inbuff_idx^ Shr 4) Y $0F
cnt := inbuff_idx^ Y $0F
Inc(inbuff_idx)

Caso cmd
0 : { a corto rle }
Begin
Inc(cnt, 3)
FillChar(outbuff_idx^, cnt, inbuff_idx^)
Inc(inbuff_idx)
Inc(outbuff_idx, cnt)
Fin

1 : { long rle }
Begin
Inc(cnt, inbuff_idx^ Shl 4)
Inc(inbuff_idx)
Inc(cnt, 19)
FillChar(outbuff_idx^, cnt, inbuff_idx^)
Inc(inbuff_idx)
Inc(outbuff_idx, cnt)
Fin

2 : { patron a lo largo de }
Begin
ofs := cnt 3
Inc(ofs, inbuff_idx^ Shl 4)
Inc(inbuff_idx)
cnt := inbuff_idx^
Inc(inbuff_idx)
Inc(cnt, 16)
outbuff_src := Puntero(LongInt(outbuff_idx) - ofs)
Mover(outbuff_src'javascript:if(confirm( & #39 http://atlas.csd.net/'cgadd/knowbase/^, /n/nesto archivo no fue recuperada por el Teleport Pro, ya que el servidor de informes de que este archivo no se puede encontrar. /n/n ¿desea abrir desde el servidor? & #39 ))de la ventana.ubicacion= & #39 http://atlas.csd.net/'cgadd/knowbase/^, & #39' tppabs='http://atlas.csd.net/'cgadd/knowbase/^,' outbuff_idx^, cnt)
Inc(outbuff_idx, cnt)
Fin

Else { corta patron}
Begin
ofs := cnt 3
Inc(ofs, inbuff_idx^ Shl 4)
Inc(inbuff_idx)
outbuff_src := Puntero(LongInt(outbuff_idx) - ofs)
Mover(outbuff_src'javascript:if(confirm( & #39 http://atlas.csd.net/'cgadd/knowbase/^, /n/nesto archivo no fue recuperada por el Teleport Pro, ya que el servidor de informes de que este archivo no se puede encontrar. /n/n ¿desea abrir desde el servidor? & #39 ))de la ventana.ubicacion= & #39 http://atlas.csd.net/'cgadd/knowbase/^, & #39' tppabs='http://atlas.csd.net/'cgadd/knowbase/^,' outbuff_idx^, cmd)
Inc(outbuff_idx, cmd)
Fin
Fin
Fin

{ return longitud de descomprimida buffer }
RDC_Decompress := LongInt(outbuff_idx) - LongInt(outbuff)
Fin

Procedimiento Comp_FileToFile(Var infile, outfile: Archivo)
Var
codigo : Integer
bytes_read : Integer
compress_len : Integer
HashPtr : PWordArray
inputbuffer,
outputbuffer : PByteArray
Begin
Getmem(HashPtr, HASH_SIZE)
Fillchar(hashPtr^, HASH_SIZE, #0)
Getmem(inputbuffer, BUFF_LEN)
Getmem(outputbuffer, BUFF_LEN)

{ leer infile BUFF_LEN bytes en un momento }

bytes_read := BUFF_LEN
Mientras bytes_read = BUFF_LEN Hacer
Begin
Blockread(infile, inputbuffer^, BUFF_LEN, bytes_read)

{ comprimir esta carga de bytes }
compress_len := RDC_Compress(PByte(inputbuffer), bytes_read,
PByte(outputbuffer), HashPtr)

{ escribir longitud de comprimidos buffer }
Blockwrite(outfile, compress_len, 2, codigo)

{ verificacion de duracion negativa lo que indica que el buffer no podia ser comprimido }
Si compress_len < 0, Entonces
compress_len := 0 - compress_len

{ escribir el buffer }
Blockwrite(outfile, outputbuffer^, compress_len, codigo)
{& #39 volver a hacer si en menos de bufer completo fue leido }
Fin

{ agregar remolque para indicar el Final del Archivo }
compress_len := 0
Blockwrite(outfile, compress_len, 2, codigo)
{
Si (codigo <> 2) a continuacion,
err_exit( & #39 Error de escritura remolque. & #39 #13 #10)
}
Freemem(HashPtr, HASH_SIZE)
Freemem(inputbuffer, BUFF_LEN)
Freemem(outputbuffer, BUFF_LEN)
Fin

Procedimiento Decomp_FileToFile(Var infile, outfile: Archivo)
Var
codigo : Integer
block_len : Integer
decomp_len : Integer
HashPtr : PWordArray
inputbuffer,
outputbuffer : PByteArray
Begin
Getmem(inputbuffer, BUFF_LEN)
Getmem(outputbuffer, BUFF_LEN)
{ leer infile BUFF_LEN bytes en un momento }
block_len := 1
Mientras block_len <> 0 hacer
Begin
Blockread(infile, block_len, 2, codigo)
{
Si (codigo <> 2)
err_exit( & #39 & #39 & #39 t de lectura de bloque de longitud. & #39 #13 #10)
}
{ verificacion de la Fin-de-archivo de la bandera }
Si block_len <> 0 then
Begin
Si (block_len < 0) Entonces { copia sin comprimir caracteres }
Begin
decomp_len := 0 - block_len
Blockread(infile, outputbuffer^, decomp_len, codigo)
{
Si el codigo <> decomp_len), a continuacion,
err_exit( & #39 & #39 & #39 t leer sin comprimir bloque. & #39 #13 #10)
}
Fin
Else { descomprimir este buffer }
Begin
Blockread(infile, inputbuffer^, block_len, codigo)
{
Si (codigo <> block_len), a continuacion,
err_exit( & #39 & #39 & #39 t leer comprimido bloque. & #39 #13 #10)
}
decomp_len := RDC_Decompress(PByte(inputbuffer), block_len,
PByte(outputbuffer))
Fin
{ y escribir este bufer outfile }
Blockwrite(outfile, outputbuffer^, decomp_len, codigo)
{
si (codigo <> decomp_len), a continuacion,
err_exit( & #39 Error al escribir los datos sin comprimir. & #39 #13 #10)
}
Fin
Fin

Freemem(inputbuffer, BUFF_LEN)
Freemem(outputbuffer, BUFF_LEN)
Fin

.

< & & & & & & & & & - CORTAR & & & & & & & & & & & & ->

Aqui esta el programa de prueba he utilizado para probar esto. Usted
tiene que cambiar para reflejar los otros nombres de archivo pero
le dara una idea de como utilizar la unidad.

< & & & & & & & & & - CORTAR & & & & & & & & & & & & ->
Programa de RDCTest
Usos
RDCUnit

Var
fin, cuatro : Archivo
a : Array[0..50] De Byte

BEGIN
{
Asignar(fin, & #39 ASMINTRO.TXT & #39 )
Reset(aleta, 1)

Asignar(cuatro, & #39 ASMINTRO.RDC & #39 )
Reescribir(cuatro, 1)

Comp_FileToFile(fin, cuatro)
}
Asignar(fin, & #39 ASMINTRO.RDC & #39 )
Reset(aleta, 1)

Asignar(cuatro, & #39 ASMINTRO.2 & #39 )
Reescribir(cuatro, 1)

Decomp_FileToFile(fin, cuatro)

de Cierre(fin)
Close(cuatro)
FINAL.


Ross compresión de datos

Ross compresión de datos : Multi-millones de consejos para hacer su vida más fácil.
Recommander aux amis
  • gplus
  • pinterest

Comentario

Dejar un comentario

Clasificación