LZSS-Einheit

LZSS-Einheit

LZSS-Einheit : Mehreren tausend Tipps, um Ihr Leben einfacher machen.

Komprimieren und Dekomprimieren von Einheit mit LZ77-Algorithmus für
Borland (Turbo) Pascal Version 7.0

Autor: ANDREW EIGUS

Einheit LZSSUnit;
{
LZSSUNIT - komprimieren und Dekomprimieren von Einheit mit LZ77-Algorithmus für
(Turbo) Borland Pascal 7.0 Version.

Assembler-Programmierer: Andy Tam, Pascal-Konvertierung: Douglas Webb,
Einheiten-Umrechnung und dynamische Speicherreservierung: Andrew Eigus.

Public-Domain-Version 1.02, Letzte Änderung am 30.11.94.
Zielplattformen: DOS, DPMI, Windows.

Geschrieben von Andrew Eigus (aka: Mr. Byte) von:
FidoNet: 2:5100 / 33,
Internet: [email protected], [email protected].
}

Schnittstelle

{#Z+}
{Diese Maßeinheit ist bereit für den Einsatz mit Dj. Murdochs-ScanHelp-Dienstprogramm die
wird ein Borland machen. TPH-Datei für sie. }
{#Z-}

const
LZRWBufSize = 8192; {Lesen Sie Puffergröße}

{#Z+}
N = 4096; {N größer -> besseren Komprimierung bei großen Dateien nur.}
F = 18;
Schwelle = 2;
NUL = N * 2;
InBufPtr: Wort = LZRWBufSize;
InBufSize: Wort = LZRWBufSize;
OutBufPtr: Wort = 0;
{#Z-}

Typ
{TWriteProc #X} {LZSquash #X} {LZUnsquash #X}

TReadProc = Function (Var ReadBuf; Var Seek_set: Wort): Wort;
{Dies ist Erklärung für benutzerdefinierte Funktion lesen. Es sollte heißen
#LZRWBufSize # Bytes aus ReadBuf. Der Rückgabewert wird ignoriert. }

{TReadProc #X} {LZSquash #X} {LZUnsquash #X}
TWriteProc = Function (Var WriteBuf; Count: Wort; Var NumWritten: Wort):
Wort; {Dies ist Erklärung für benutzerdefinierte Write-Funktion. Es sollte schreiben
Anzahl Bytes in WriteBuf und Rücksendungsnummer der tatsächlichen geschriebenen bytes
in NumWritten Variable. Der Rückgabewert wird ignoriert. }

{#Z+}
PLZRWBuffer = ^ TLZRWBuffer;
TLZRWBuffer = Array [0..LZRWBufSize - 1] Byte; {Dateipuffer}

PLZTextBuf = ^ TLZTextBuf;
TLZTextBuf = Byte-Array [0..N + F - 2];

PLeftMomTree = ^ TLeftMomTree;
TLeftMomTree = Array [0..N] des Wortes;
PRightTree = ^ TRightTree;
TRightTree = array [0..N + 256] des Wortes;

const
LZSSMemRequired = SizeOf(TLZRWBuffer) * 2 +
SizeOf(TLZTextBuf) + SizeOf(TLeftMomTree) * 2 + SizeOf(TRightTree);
{#Z-}

Funktion LZInit: boolean;
{Diese Funktion sollte vor allen anderen Kompression-Routinen aufgerufen werden
von diesem Gerät - es wird Arbeitsspeicher und initialisiert alle internen
Variablen von Kompressionsverfahren benötigt. Wenn die Reservierung fehlschlägt,
LZInit gibt False zurück, das bedeutet, dass es nicht genügend Speicher für
Komprimierung oder Dekomprimierung Prozess. Es gibt True zurück, wenn Initialisierung
erfolgreich war. }
{LZDone #X} {LZSquash #X} {LZUnsquash #X}

Prozedur LZSquash (ReadProc: TReadProc; WriteProc: TWriteProc);
{Diese Prozedur ist für die Komprimierung verwendet. ReadProc gibt benutzerdefinierte
Lesen Sie Funktion, die liest Daten und WriteProc gibt benutzerdefinierte schreiben
Funktion, die komprimierte Daten schreibt. }
{LZUnsquash #X} {LZInit #X} {LZDone #X}

Prozedur LZUnSquash (ReadProc: TReadProc; WriteProc: TWriteProc);
{Diese Prozedur dient zur Dekompression. ReadProc gibt benutzerdefinierte
Lesen Sie Funktion, die komprimierte Daten und WriteProc liest gibt
benutzerdefinierte Write-Funktion, die schreibt dekomprimiert Daten. }
{LZSquash #X} {LZInit #X} {LZDone #X}

Prozedur LZDone;
{Diese Prozedur sollte aufgerufen werden, nachdem Sie die Komprimierung abgeschlossen oder
Dekompression. Es hebt (befreit) alle Speicher von LZInit.
Hinweis: Sie sollten immer LZDone aufrufen, nachdem Sie mit Kompression
Routinen von diesem Gerät. }
{LZInit #X} {LZSquash #X} {LZUnsquash #X}

Umsetzung

var
Höhe, MatchPos, MatchLen, LastLen: Wort;
TextBufP: PLZTextBuf;
LeftP, MomP: PLeftMomTree;
RightP: PRightTree;
CodeBuf: Byte-Array [0..16];
LZReadProc: TReadProc;
LZWriteProc: TWriteProc;
InBufP, OutBufP: PLZRWBuffer;
Byte: Wort;
Initialisiert: Boolean;

Funktion LZSS_Read: Wort; {Gibt die Anzahl der gelesenen Bytes}
BEGIN
LZReadProc (InBufP ^, Bytes);
LZSS_Read: Byte;
Ende; {LZSS_Read}

Funktion LZSS_Write: Wort; {Gibt die Anzahl der geschriebenen Bytes}
BEGIN
LZWriteProc (OutBufP ^, OutBufPtr, Bytes);
LZSS_Write: = Bytes
Ende; {LZSS_Write}

Verfahren Getc; Assembler;
ASM
{
Getc: gibt ein Zeichen aus dem Puffer zurück
Rückfahrt: AL = Eingabe Char
Tragen festgelegt, wenn EOF
}
Push bx
MOV Bx, inBufPtr
CMP-Bx, inBufSize
JB @getc1
Push cx
Push-dx
Stoß-di
Drücken si
Aufruf LZSS_Read
Pop-si
Pop di
Pop-dx
Pop cx
MOV InBufSize, ax
oder Ax, ax
JZ @getc2 {; EOF}
XOR Bx, Bx
die @getc1:
PUSH-DI
LES DI, [InBufP]
MOV AL, BYTE PTR [ES:DI + BX]
POP-DI
Inc-bx
MOV InBufPtr, bx
Pop bx
CLC {; das Carry-Flag löschen}
Jmp @end
@getc2: pop Bx
STC {; Set tragen an EOF}
die @end:
Ende; {Getc}

Putc Verfahren; Assembler;
{
Putc: setzen ein Zeichen in den Ausgabepuffer
Eintrag: AL = Ausgabe Char
}
ASM
Push bx
MOV Bx, outBufPtr
PUSH-DI
LES DI, [OutBufP]
MOV BYTE PTR [ES:DI + BX], AL
POP-DI
Inc-bx
CMP-Bx, LZRWBufSize
JB @putc1
MOV OutBufPtr, LZRWBufSize {nur damit die Spülung funktioniert.}
Push cx
Push-dx
Stoß-di
Drücken si
Aufruf LZSS_Write
Pop-si
Pop di
Pop-dx
Pop cx
XOR Bx, Bx
@putc1: Mov OutBufPtr, Bx
Pop bx
Ende; {Putc}

Verfahren InitTree; Assembler;
{
InitTree: alle Binärsuche Bäume zu initialisieren. Es gibt 256 BST, einer
für alle Zeichenfolgen, die Schritte mit ein bestimmtes Zeichen. Die
übergeordnet ist Baum K ist der Knoten N + K + 1 und es hat nur eine
richtige Kind
}
ASM
könnte
Stoß-ds
Pop es
LES DI, [RightP]
{Mov di, versetzt rechts}
Hinzufügen von di (N + 1) * 2
MOV Cx, 256
MOV Ax, NUL
Rep-stosw
LES DI, [MomP]
{Mov di, versetzte Mutter}
MOV Cx, N
Rep-stosw
Ende; {InitTree}

Verfahren Splay; Assembler;
{
splay: splay-Baum-Operationen verwenden, um den Knoten nach 'oben' zu verschieben
Baum. Beachten Sie, dass es keine echten wird die Wurzel des Baumes zu werden
Da die Wurzel jeder Baum eine spezielle Knoten ist. Y11:
PUSH BX
LES BX, [MomP]
MOV [ES:BX + DI], SI
POP BX
{[Offset Mom + di] Mov, Si}
Jmp @Splay1
die @end:
Ende; {SPlay}

Prozedur InsertNode; Assembler;
{
InsertNode: Legen Sie den neuen Knoten an die entsprechende Struktur. tP]
CMP-SI, WORD PTR [ES:DI + BX]
POP-DI
{Cmp-Si, Wort Ptr [Offset rechts + Bx]}
JNE @del4
DRÜCKEN SI
LES SI, [RightP]
MOV WORD PTR [ES:SI + BX], DI
POP-SI
{Mov Wort Ptr [Offset rechts + Bx], di}
Jmp @del5
die @del4:
DRÜCKEN SI
LES SI, [LeftP]
MOV WORD PTR [ES:SI + BX], DI
POP-SI
{Mov Wort Ptr [Offset Links + Bx], di}
die @del5:
PUSH-DI
LES DI, [MomP]
HINZUFÜGEN DI, SI
MOV WORD PTR [ES:DI], NUL
POP-DI
{Mov Wort Ptr [Offset Mom + Si], NUL}
@del7: pop Bx
Pop di
SHR Si, 1
Jmp @end;
die @del8:
PUSH BX
LES BX, [LeftP]
MOV DI, WORD PTR [ES:BX + SI]
POP BX
{Mov di, Wort Ptr [Offset Links + Si]}
Jmp @del3
die @del9:
PUSH BX
LES BX, [RightP]
MOV DI, WORD PTR [ES:BX + SI]
POP BX
{Mov di, Wort Ptr [Offset rechts + Si]}
Jmp @del3
die @end:
Ende; {DeleteNode}

Verfahren kodieren; Assembler;
ASM
Rufen Sie initTree
XOR Bx, Bx
MOV [Offset CodeBuf + Bx], bl
MOV Dx, 1
MOV-ch, dl
XOR-Si, si
MOV di, N - F
@Encode2: Getc aufrufen
JC @Encode3
DRÜCKEN SI
LES SI, [TextBufP]
HINZUFÜGEN SI, DI
MOV BYTE PTR [ES:SI + BX], AL
POP-SI
{Mov Byte Ptr [Offset TextBuf + di + Bx], al}
Inc-bx
CMP-Bx, F
JB @Encode2
@Encode3: oder Bx, Bx
JNE @Encode4
Jmp @Encode19
@Encode4: Mov cl, Bl
MOV Bx, 1
Stoß-di
Sub-di, 1
@Encode5: InsertNode aufrufen
Inc-bx
di Dez
CMP-Bx, F
Jbe @Encode5
Pop di
Rufen Sie InsertNode
@Encode6: Mov Ax, MatchLen
CMP al, cl
Jbe @Encode7
MOV al, cl
MOV MatchLen, ax
@Encode7: Cmp al, SCHWELLENWERT
Ja @Encode8
MOV MatchLen, 1
oder Byte Ptr CodeBuf, ch
MOV Bx, dx
DRÜCKEN SI
LES SI, [TextBufP]
HINZUFÜGEN SI, DI
MOV AL, BYTE PTR [ES:SI]
POP-SI
{Mov al, Byte Ptr [Offset TextBuf + di]}
MOV Byte Ptr [Offset CodeBuf + Bx], al
Inc-dx
Jmp @Encode9
@Encode8: Mov Bx, Dx
MOV al, Byte Ptr matchPos
MOV Byte Ptr [Offset Codebuf + Bx], al
Inc-bx
MOV al, Byte Ptr (MatchPos + 1)
Push cx
MOV cl, 4
SHL-al, cl
Pop cx
MOV ah, Byte Ptr MatchLen
Sub Ach, Schwelle + 1
Hinzufügen von al, ah
MOV Byte Ptr [Offset Codebuf + Bx], al
Inc-bx
MOV Dx, bx
@Encode9: Shl LM, 1
JNZ @Encode11
XOR Bx, Bx
@Encode10: Mov al, Byte Ptr [Offset CodeBuf + Bx]
Putc aufrufen
Inc-bx
CMP-Bx, dx
JB @Encode10
MOV Dx, 1
MOV-ch, dl
MOV Byte Ptr CodeBuf, dh
@Encode11: Mov Bx, MatchLen
MOV LastLen, bx
XOR Bx, Bx
@Encode12: Getc aufrufen
{@Encode14 Jc}
JC @Encode15
Push ax
Aufruf deleteNode
Pop ax
PUSH-DI
LES DI, [TextBufP]
HINZUFÜGEN DI, SI
stosb
POP-DI
{Mov Byte Ptr [Offset TextBuf + Si], al}
CMP Si, F - 1
Jae @Encode13
PUSH-DI
LES DI, [TextBufP]
HINZUFÜGEN DI, SI
MOV BYTE PTR [ES:DI + N], AL
POP-DI
{Mov Byte Ptr [Offset TextBuf + Si + N], al}
@Encode13: inc Si
und Si, N - 1
Inc-di
und di, N - 1
Rufen Sie insertNode
Inc-bx
CMP-Bx, lastLen
JB @Encode12
(* @Encode14: sub PrintCount, Bx
JNC @Encode15
MOV Ax, printPeriod
MOV PrintCount, ax
Push-Dx {Print aus einer Zeit als ein Zeichen.