Ross compression de données

Ross compression de donnees

Ross compression de donnees : Plusieurs milliers de conseils pour vous faciliter la vie.

Pascal mise en œuvre adaptee de C code source.

l'auteur: MIKE CHAPIN

{
eh Bien la voila, comme promis. C'est un Pascal le port de Ross
la compression de Donnees. Cette unite n'a pas de tampon
de compression/decompression, mais vous pouvez ajouter si vous le souhaitez.
L'implementation C je l'ai fait a un Tampon de compression de fichier
et le fichier de la memoire tampon de decompression.

C'est un cadeau et est disponible pour des SWAG si ils
vous voulez.

types de donnees Communs de l'unite que j'utilise beaucoup. Ressemble Delphi
integre de type similaire.

}
(*
types de donnees Communs et les structures.
*)

Unite Commune de
Interface

Type
PByte = ^Octet
ByteArray = Array[0..65000] Of Byte
PByteArray = ^ByteArray

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

PWord = ^Mot
WordArray = Array[0..32000] Du Mot
PWordArray = ^WordArray

la mise en Œuvre

a la FIN.

(***************************************************
* RDC *
* *
* C'est un Pascal le port de code C a partir d'un article *
* Dans 'Le C Utilisateurs Journal', 1/92 Ecrit par *
* Ed Ross. *
* *
* Ce code a bien fonctionne en vertu de l', *
* Reel, Protege et Windows. *
* *
* La compression n'est pas tout a fait aussi bon que PKZIP *
* mais il decompresse environ 5 fois plus rapide. *
***************************************************)
Unite de RDCUnit
Interface

Commun

Procedure Comp_FileToFile(Var infile, outfile: Fichier)
Procedure Decomp_FileToFile(Var infile, outfile: Fichier)

Application
Const
HASH_LEN = 4096 { # hash table entries }
HASH_SIZE = HASH_LEN * Sizeof(mot)
BUFF_LEN = 16384 { taille d'e / s de disque tampon }

(*
compresser inbuff_len octets de inbuff en outbuff
a l'aide de hash_len entrees dans hash_tbl.

le retour de la longueur de outbuff, ou '0 - inbuff_len'
si inbuff ne pouvait pas etre compresse.
*)
Fonction de rdc_compress(ibuff : Pointeur
inbuff_len : Mot
obuff : Pointeur
htable : Pointeur) : Integer
Var
inbuff : PByte Absolue ibuff
outbuff : PByte Absolue obuff
hash_tbl : PWordArray Absolue htable
in_idx : PByte
in_idxa : PByteArray absolue in_idx
inbuff_end : PByte
ancre : PByte
pat_idx : PByte
cnt : Mot
lacune : le Mot
c : Mot
hash : Mot
hashlen : Mot
ctrl_idx : PWord
ctrl_bits : Mot
ctrl_cnt : Mot
out_idx : PByte
outbuff_end : PByte
Begin
in_idx := inbuff
inbuff_end :Pointeur = (LongInt(inbuff) inbuff_len)
ctrl_idx := Pointeur(outbuff)
ctrl_cnt := 0

out_idx := Pointeur(longint(outbuff) Sizeof(Mot))
outbuff_end := Pointeur(LongInt(outbuff) (inbuff_len - 48))

{ skip la compression pour un petit tampon }

Si inbuff_len <= 18 then
Begin
Move(outbuff, inbuff, inbuff_len)
rdc_compress := 0 - inbuff_len
Sortie
Fin

{ ajuster # hachage entrees de sorte algorithme de hachage peut
& #39 et & #39 au lieu de & #39 mod & #39 }

hashlen := HASH_LEN - 1

{ balayage thru inbuff }

Alors que LongInt(in_idx) < LongInt(inbuff_end) Ne
Begin
{ faire de la place pour les bits de controle
et verifier outbuff debordement }

Si ctrl_cnt = 16
Begin
ctrl_idx^ := ctrl_bits
ctrl_cnt := 1
ctrl_idx :Pointeur = (out_idx)
Inc(word(out_idx), 2)
Si LongInt(out_idx) > LongInt(outbuff_end)
Begin
Move(outbuff, inbuff, inbuff_len)
rdc_compress := inbuff_len
Sortie
Fin
Fin
Else
Inc(ctrl_cnt)

{ look pour rle }

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

While (LongInt(in_idx) < longint(inbuff_end))
Et (in_idx^ = c)
Et (LongInt(in_idx) - LongInt(ancre) < (HASH_LEN 18)) Do
Inc(in_idx)

{ magasin de compression code si le caractere est
repetees plus de 2 fois }

cnt := LongInt(in_idx) - LongInt(ancre)
Si la cnt > 2
Begin
Si la cnt <= 18 Then { court rle }
Begin
out_idx^ := cnt - 3
Inc(out_idx)
out_idx^ := c
Inc(out_idx)
Fin
Else { long rle }
Begin
Dec(cnt, 19)
out_idx^ := 16 (cnt et $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) Ou 1

Fin

{ regarder pour le modele si 2 ou plus de caracteres
restent dans la memoire tampon d'entree }

in_idx := ancre

Si (LongInt(inbuff_end) - LongInt(in_idx)) > 2
Begin
{ localiser decalage de modele possible
en glissement dictionnaire }

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

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

{ comparer les caracteres si nous & #39 re dans 4098 octets }

lacune := LongInt(in_idx) - LongInt(pat_idx)
If (ecart <= HASH_LEN 2)
Begin
While (LongInt(in_idx) < LongInt(inbuff_end))
Et (LongInt(pat_idx) < LongInt(ancre))
Et (pat_idx^ = in_idx^)
Et (LongInt(in_idx) - LongInt(ancre) < 271) Ne
Begin
Inc(in_idx)
Inc(pat_idx)
Fin

{ magasin modele, s'il est plus de 2 caracteres }

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

Si cnt <= 15 Alors { court motif }
Begin
out_idx^ := (cnt Shl 4) (ecart Et $0F)
Inc(out_idx)
out_idx^ := ecart Shr 4
Inc(out_idx)
Fin
Else { long motif }
Begin
out_idx^ := 32 (ecart Et $0F)
Inc(out_idx)
out_idx^ := ecart Shr 4
Inc(out_idx)
out_idx^ := cnt - 16
Inc(out_idx)
Fin

ctrl_bits := (ctrl_bits Shl 1) Ou 1

Fin
Fin
Fin

{ peut & #39 t compresser ce personnage
donc le copier a outbuff }

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

{ enregistrer la derniere charge de bits de controle }

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

{ et de retour de la taille de comprime tampon }

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

(*
decompresser inbuff_len octets de inbuff en outbuff.

le retour de la longueur de outbuff.
*)
Fonction de RDC_Decompress(inbuff : PByte
inbuff_len : Mot
outbuff : PByte) : Integer
Var
ctrl_bits : Mot
ctrl_mask : Mot
inbuff_idx : PByte
outbuff_idx : PByte
inbuff_end : PByte
cmd, cnt : Mot
ofs, len : Mot
outbuff_src : PByte
Begin
ctrl_mask := 0
inbuff_idx := inbuff
outbuff_idx := outbuff
inbuff_end := Pointeur(LongInt(inbuff) inbuff_len)

{ traiter chaque element dans inbuff }
Alors que LongInt(inbuff_idx) < LongInt(inbuff_end) Ne
Begin
{ get nouvelle charge de bits de controle, si necessaire }
ctrl_mask := ctrl_mask Shr 1
Si ctrl_mask = 0, Alors
Begin
ctrl_bits := PWord(inbuff_idx)^
Inc(inbuff_idx, 2)
ctrl_mask := $8000
Fin

{ il suffit de copier ce char si le bit de controle est egal a zero }
If (ctrl_bits Et ctrl_mask) = 0, Alors
Begin
outbuff_idx^ := inbuff_idx^
Inc(outbuff_idx)
Inc(inbuff_idx)

Fin

{ annuler la compression code }
cmd := (inbuff_idx^ Shr 4) Et $0F
cnt := inbuff_idx^ Et $0F
Inc(inbuff_idx)

en Cas de cmd
0 : { court 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 : { long motif }
Begin
ofs := cnt 3
Inc(ofs, inbuff_idx^ Shl 4)
Inc(inbuff_idx)
cnt := inbuff_idx^
Inc(inbuff_idx)
Inc(cnt, 16)
outbuff_src := Pointeur(LongInt(outbuff_idx) - ofs)
Move(outbuff_src'javascript:if(confirm( & #39 http://atlas.csd.net/'cgadd/knowbase/^, \n\nce fichier n'a pas ete recupere par Teleport Pro, parce que le serveur de rapports que ce fichier ne peut etre trouve. \n\nvoulez-vous pour l'ouvrir a partir du serveur? & #39 ))de la fenetre.emplacement= & #39 http://atlas.csd.net/'cgadd/knowbase/^, & #39' tppabs='http://atlas.csd.net/'cgadd/knowbase/^,' outbuff_idx^, cnt)
Inc(outbuff_idx, cnt)
Fin

Else { court motif}
Begin
ofs := cnt 3
Inc(ofs, inbuff_idx^ Shl 4)
Inc(inbuff_idx)
outbuff_src := Pointeur(LongInt(outbuff_idx) - ofs)
Move(outbuff_src'javascript:if(confirm( & #39 http://atlas.csd.net/'cgadd/knowbase/^, \n\nce fichier n'a pas ete recupere par Teleport Pro, parce que le serveur de rapports que ce fichier ne peut etre trouve. \n\nvoulez-vous pour l'ouvrir a partir du serveur? & #39 ))de la fenetre.emplacement= & #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 longueur de decompresse buffer }
RDC_Decompress := LongInt(outbuff_idx) - LongInt(outbuff)
Fin

Procedure Comp_FileToFile(Var infile, outfile: Fichier)
Var
code : 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)

{ lire infile BUFF_LEN octets a la fois }

bytes_read := BUFF_LEN
Alors que bytes_read = BUFF_LEN Ne
Begin
Blockread(infile, inputbuffer^, BUFF_LEN, bytes_read)

{ compresser cette charge d'octets }
compress_len := RDC_Compress(PByte(inputbuffer), bytes_read,
PByte(outputbuffer), HashPtr)

{ ecrire la longueur de comprime tampon }
Blockwrite(outfile, compress_len, 2, code)

{ verifier la longueur negative indiquant la memoire tampon peut pas etre compresse }
Si compress_len < 0 Alors
compress_len := 0 - compress_len

{ ecrire la memoire tampon }
Blockwrite(outfile, outputbuffer^, compress_len, code)
{ nous & #39 re fait si moins complete de la memoire tampon a ete lu }
Fin

{ ajouter remorque pour indiquer la Fin du Fichier }
compress_len := 0
Blockwrite(outfile, compress_len, 2, code)
{
if (code <> 2) puis
err_exit( & #39 Erreur lors de l'ecriture de la remorque. & #39 #13 #10)
}
Freemem(HashPtr, HASH_SIZE)
Freemem(inputbuffer, BUFF_LEN)
Freemem(outputbuffer, BUFF_LEN)
Fin

Procedure Decomp_FileToFile(Var infile, outfile: Fichier)
Var
code : Integer
block_len : Integer
decomp_len : Integer
HashPtr : PWordArray
inputbuffer,
outputbuffer : PByteArray
Begin
Getmem(inputbuffer, BUFF_LEN)
Getmem(outputbuffer, BUFF_LEN)
{ lire infile BUFF_LEN octets a la fois }
block_len := 1
Alors que block_len <> 0 do
Begin
Blockread(infile, block_len, 2, code)
{
if (code <> 2)
err_exit( & #39 & #39 & #39 t lire la longueur de bloc. & #39 #13 #10)
}
{ case pour Fin-de-fichier drapeau }
Si block_len <> 0 then
Begin
If (block_len < 0) Alors { copie non compresse caracteres }
Begin
decomp_len := 0 - block_len
Blockread(infile, outputbuffer^, decomp_len, code)
{
Si le code <> decomp_len)
err_exit( & #39 & #39 & #39 t lire non compresse bloc. & #39 #13 #10)
}
Fin
Else { decompresser ce tampon }
Begin
Blockread(infile, inputbuffer^, block_len, code)
{
if (code <> block_len)
err_exit( & #39 & #39 & #39 t lire comprime de bloc. & #39 #13 #10)
}
decomp_len := RDC_Decompress(PByte(inputbuffer), block_len,
PByte(outputbuffer))
Fin
{ et ecrire ce tampon outfile }
Blockwrite(outfile, outputbuffer^, decomp_len, code)
{
if (code <> decomp_len)
err_exit( & #39 Erreur d'ecriture des donnees non compressees. & #39 #13 #10)
}
Fin
Fin

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

a la FIN.

< & & & & & & & & & - COUPER & & & & & & & & & & & & ->

Voici le programme de test que j'ai utilise pour le test. Vous
avoir a le changer pour refleter les autres noms de fichier, mais il
vous donnera une idee de la façon d'utiliser l'unite.

< & & & & & & & & & - COUPER & & & & & & & & & & & & ->
Programme de RDCTest

RDCUnit

Var
fin, fout : Fichier
a : Array[0..50] Of Byte

BEGIN
{
Assign(fin, & #39 ASMINTRO.TXT & #39 )
Reinitialiser(fin, 1)

Assign(fout, & #39 ASMINTRO.RDC & #39 )
Reecriture(fout, 1)

Comp_FileToFile(fin, fout)
}
Assign(fin, & #39 ASMINTRO.RDC & #39 )
Reinitialiser(fin, 1)

Assign(fout, & #39 ASMINTRO.2 & #39 )
Reecriture(fout, 1)

Decomp_FileToFile(fin, fout)

Close(fin)
Close(fout)
a la FIN.