Einheit LZSS

April 10, 2016 Admin Computer 0 19
FONT SIZE:
fontsize_dec
fontsize_inc

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

Anbieter: ANDREW EIGUS

Einheit LZSSUnit;
{
LZSSUNIT - komprimiert und mit Hilfe der LZ77-Algorithmus für dekomprimieren Einheit
Borland (Turbo) Pascal Version 7.0.

Assembler Programmierer: Andy Tam, Pascal Konvertierung: Douglas Webb,
Unit Conversion und dynamische Speicherverwaltung: Andrew Eigus.

Public Domain-Version 1.02, die neueste Änderung auf 11/30/94.
Zielplattformen: DOS, DPMI, Windows.

Geschrieben von Andrew Eigus (aka: Mr. Byte) zu:
Fidonet: 2: 5100/33,
Internet: aeigus@fgate.castle.riga.lv, aeigus@kristin.cclu.lv.
}

Schnittstelle

# {Z +}
{Dieses Gerät ist für den Einsatz mit Dj. Dienstprogramme ScanHelp Murdoch, der
.TPH Borland wird eine Datei für sie zu machen. }
# {Z}

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

# {Z +}
N = 4096; {Bigger N -> Bessere Kompression nur bei großen Dateien. }
F = 18;
Threshold = 2;
Nul = N * 2;
InBufPtr: Wort = LZRWBufSize;
InBufSize: Wort = LZRWBufSize;
OutBufPtr: Wort = 0;
# {Z}

So'ne Art
#X TWriteProc {} {} {# X # X LZSquash LZUnsquash}

TReadProc = function (ReadBuf var, var NumRead: Wort): word;
{Dies ist die Erklärung für die Funktion der personalisierten Lesen. Sie lesen sollten
# # LZRWBufSize Bytes aus ReadBuf. Der Rückgabewert wird ignoriert. }

#X TReadProc {} {} {# X # X LZSquash LZUnsquash}
TWriteProc = function (var WriteBuf; Graf: word; NumWritten var: Wort):
Wort; {Dies ist die Erklärung für die Funktion des kundenspezifischen Schreiben. Sie sollten schreiben
Count Bytes in WriteBuf und die Anzahl der Bytes, die tatsächlich zurückgeschrieben
variable NumWritten. Der Rückgabewert wird ignoriert. }

# {Z +}
PLZRWBuffer = ^ TLZRWBuffer;
TLZRWBuffer = array [0..LZRWBufSize - 1] of Byte; Puffer {file}

PLZTextBuf = ^ TLZTextBuf;
TLZTextBuf = array [0..n + F - 2] of Byte;

PLeftMomTree = ^ TLeftMomTree;
TLeftMomTree = array [0..n] von Word;
PRightTree = ^ TRightTree;
TRightTree = array [0..n + 256] von Word;

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

LZInit Funktion: boolean;
{Diese Funktion muss vor allen anderen Komprimierungsroutinen aufgerufen werden
von diesem Gerät - es weist Speicher und initialisiert alle internen
Variablen, die den Verfahren der Kompression erforderlich. Wenn die Zuweisung fehlschlägt,
LZInit false zurückgibt, bedeutet dies, dass es nicht genügend Speicher zur
Kompression oder Dekompression. Gibt True zurück, wenn die Initialisierung
war erfolgreich. }
#X LZDone {} {} {# X # X LZSquash LZUnsquash}

Verfahren LZSquash (readproc: TReadProc; writeproc: TWriteProc);
{Dieses Verfahren wird für die Komprimierung verwendet. Readproc Kundenspezifikation
Funktion, die die Daten lesen liest, und writeproc bestimmte benutzerdefinierte Schreib
Funktion, die die komprimierten Daten schreibt. }
#X LZUnsquash {} {} {# X # X LZInit LZDone}

Verfahren LZUnSquash (readproc: TReadProc; writeproc: TWriteProc);
{Dieses Verfahren wird für die Dekomprimierung verwendet. Readproc Kundenspezifikation
Funktion, die die komprimierten Daten liest und writeproc spezifischen Lese
Schreiben von benutzerdefinierten Funktion, die die unkomprimierten Daten schreibt. }
#X LZSquash {} {} {# X # X LZInit LZDone}

LZDone Verfahren;
{Dieses Verfahren sollte nach Beendigung der Kompression genannt werden oder
Dekompression. Es löst (befreit) alle Speicher durch LZInit zugeordnet.
Hinweis: Sie sollten immer LZDone nennen, nachdem Sie mit der Kompression beendet haben
Routine dieser Einheit. }
#X LZInit {} {} {# X # X LZSquash LZUnsquash}

Ausführung

var
Höhe, MatchPos, MatchLen, LastLen: word;
TextBufP: PLZTextBuf;
LeftP, MOMP: PLeftMomTree;
RightP: PRightTree;
CodeBuf: array [0..16] of Byte;
LZReadProc: TReadProc;
LZWriteProc: TWriteProc;
InBufP, OutBufP: PLZRWBuffer;
Bytes Wort;
initialisiert: boolean;

Funktion LZSS_Read: word; {# Kosten der gelesenen Bytes}
Start
LZReadProc (InBufP ^ Byte);
LZSS_Read: = Bytes;
Ende; LZSS_Read {}

Funktion LZSS_Write: word; {# Gibt der geschriebenen Bytes}
Start
LZWriteProc (OutBufP ^, OutBufPtr, Bytes);
LZSS_Write: = Bytes
Ende; LZSS_Write {}

GETC Verfahren; Assembler;
Asm
{
getc: Rückkehr ein Zeichen aus dem Puffer
RETURN: AL = char Eingangs
Carry gesetzt, wenn EOF
}
Push bx
mov bx, inBufPtr
cmp bx, inBufSize
jb @ getc1
Push cx
Push dx
Schub
Push SI
rufen LZSS_Read
Pop SI
Pop
Pop dx
pop cx
mov inBufSize, Axt
oder Axt, Axt
jz @ getc2 {; EOF}
xor bx, bx
@ getc1:
PUSH TO
LES DI [InBufP]
MOV AL, BYTE PTR [ES: BX + DI]
OF POP
inc bx
mov inBufPtr, bx
pop bx
{clc; deaktivieren Sie das Carry-Flag}
jmpend
@ getc2: pop bx
{stc; gesetzt zu tragen, um anzuzeigen, EOF}
Ende:
Ende; GETC {}

Verfahren putc; Assembler;
{
putc: Setzen Sie ein Zeichen in der Ausgabepuffer
Eintrag: AL = char Ausgangs
}
Asm
Push bx
mov bx, outBufPtr
PUSH TO
LES DI [OutBufP]
MOV BYTE PTR [ES: DI + BX], AL
OF POP
inc bx
cmp bx, LZRWBufSize
jb @ putc1
mov OutBufPtr, LZRWBufSize {Nur damit der Faden zu arbeiten. }
Push cx
Push dx
Schub
Push SI
rufen LZSS_Write
Pop SI
Pop
Pop dx
pop cx
xor bx, bx
@ putc1: mov outBufPtr, bx
pop bx
Ende; {} Putc

InitTree Verfahren; Assembler;
{
initTree: initialisieren alle binären Suchbäume. Es gibt 256 BST, eine
für alle Saiten begann mit einem besonderen Charakter. Die
geordnete Baumknoten K ist die n + k + 1, und es gibt nur einen
rechte Kind
}
Asm
CLD
drücken ds
Pop ES
LES DI [RightP]
{mov, nach rechts versetzt}
hinzuzufügen, (N + 1) * 2
mov cx, 256
mov ax, NUL
rep stosw
LES DI [MOMP]
{mov, Mutter von Offset}
mov cx, N
rep stosw
Ende; InitTree {}

Spreizfuß Verfahren; Assembler;
{
Anzeige: Verwendung Spreizfuß Baum-Operationen, um den Knoten auf die 'top' der Bewegung
Baum. Beachten Sie, dass es die eigentliche Wurzel des Baumes
weil die Wurzel jedes Baumes ist eine spezielle Knoten. Stattdessen
werden die richtige Kind dieses Knotens Besonderes.

INPUT: = die Knoten gedreht werden
}
Asm
@ Splay1:
PUSH BX
LES BX, [MOMP]
MOV SI, [ES: BX + DI]
POP BX
{mov si, [+ Mutter von Offset]}
cmp ist, {NUL; ausgegeben, wenn die Mutter ist eine besondere
Knoten} @ ja Splay4
PUSH TO
LES DI [MOMP]
ADD DI, SI
MOV BX, [ES: DI]
{mov bx, [Offset + Mutter ist]}
OF POP
cmp bx, {NUL; überprüfen, ob sein Großvater ist das Besondere
JBE} {@ Splay5; wenn nicht, dann überspringen}
PUSH BX
LES BX, [LeftP]
CMP DI [ES: BX + SI]
POP BX
{cmp von [Offset Links + sc] {}; ist der aktuelle Knoten ein
links Kind? JNE @} Splay2
PUSH BX
LES BX, [RightP]
MOV DX, [ES: BX + DI]
{mov dx, [Offset + Recht] {}; führen eine Zick links
Betrieb} LES BX, [LeftP]
MOV [ES: BX + SI], DX
{mov [Offset Links + si], dx}
LES BX, [RightP]
MOV [ES: BX + DI], SI
POP BX
{mov [+ Rechts der Offset], SI}
JMP @ Splay3
@ Splay2:
PUSH BX
LES BX, [LeftP]
MOV DX, [ES: BX + DI]
{mov dx, [Offset + links] {}; das Recht auf eine Zick laufen}
LES BX, [RightP]
MOV [ES: BX + SI], DX
{mov [Offset Rechts + SI], dx}
LES BX, [LeftP]
MOV [ES: BX + DI], SI
POP BX
{mov [Offset Left +], SI}
@ Splay3:
PUSH SI
LES SI, [RightP]
MOV [ES: BX + SI], DI
POP SI
{mov [bx + Offset Rechts]} von
xchg bx, dx
PUSH AX
MOV AX, BX
LES BX, [MOMP]
ADD BX, AX
MOV [ES: BX], SI
LES BX, [MOMP]
MOV [ES: BX + SI], DI
LES BX, [MOMP]
MOV [ES: BX + DI], DX
MOV BX, AX
POP AX
{mov, sc [Mom + bx Offset]
mov [Mama + si Offset], für
mov [Offset + Mutter] dx}
@ Splay4: Ende JMP
@ Splay5:
PUSH TO
LES DI [MOMP]
MOV CX, [ES: BX + DI]
OF POP
{mov cx, [Mutter + bx Offset]}
PUSH BX
LES BX, [LeftP]
CMP DI [ES: BX + SI]
POP BX
{cmp von [Offset + wird links]}
JNE @ Splay7
PUSH TO
LES DI [LeftP]
CMP SI, [ES: BX + DI]
OF POP
{cmp ist, [Offset Links + bx]}
JNE @ Splay6
PUSH AX
MOV AX, DI
LES DI [RightP]
ADD DI, SI
MOV DX, [ES: DI]
{mov dx, [Rechts + sc Offset] {}; führen Sie einen Zick-Zick links
Betrieb} LES DI [LeftP]
MOV [ES: BX + DI], DX
{mov [bx + links Offset], dx}
xchg bx, dx
LES DI [MOMP]
MOV [ES: BX + DI], DX
{mov dx [Mom + bx Offset]}
LES DI [RightP]
ADD DI, AX
MOV BX, [ES: DI]
{mov bx, [Offset + Recht]}
LES DI [LeftP]
ADD DI, SI
MOV [ES: DI], BX
LES DI [MOMP]
MOV [ES: BX + DI], SI
{mov [Offset Links + si], bx
mov [bx + Offset Mutter], SI}
mov bx, dx
LES DI [RightP]
ADD DI, SI
MOV [ES: DI], BX
LES DI [RightP]
ADD DI, AX
MOV [ES: DI], SI
{mov [Offset Rechts + SI], bx
mov [+ Rechts der Offset], SI}
LES DI [MOMP]
MOV [ES: BX + DI], SI
LES DI [MOMP]
ADD DI, SI
STOSW
MOV DI, AX
POP AX
{mov, sc [Mom + bx Offset]
mov [Mama + si Offset], für}
JMP @ Splay9
@ Splay6:
PUSH AX
MOV AX, SI
LES SI, [LeftP]
ADD SI, DI
MOV DX, [ES: SI]
{mov dx, [Offset + links] {}; führen Seitenzickzack
Betrieb} LES SI, [RightP]
MOV [ES: BX + SI], DX
{mov [bx + rechts versetzt], dx}
xchg bx, dx
LES SI, [MOMP]
MOV [ES: BX + SI], DX
{mov dx [Mom + bx Offset]}
LES SI, [RightP]
ADD SI, DI
MOV BX, [ES: SI]
{mov bx, [Offset + Recht]}
LES SI, [LeftP]
ADD SI, AX
MOV [ES: SI], BX
{mov [Offset Links + si], bx}
LES SI, [MOMP]
MOV [ES: BX + SI], AX
{mov, sc [Mom + bx Offset]}
mov bx, dx
LES SI, [LeftP]
ADD SI, DI
MOV [ES: SI], BX
{mov [Offset Left +], bx}
LES SI, [RightP]
ADD SI, DI
MOV [ES: SI], AX
{mov [+ Rechts der Offset], SI}
LES SI, [MOMP]
ADD SI, AX
MOV [ES: SI], DI
{mov [Offset Mutter + si], für}
LES SI, [MOMP]
MOV [ES: BX + SI], DI
MOV SI, AX
POP AX
{mov, der [Mom + bx Offset]}
JMP @ Splay9
@ Splay7:
PUSH TO
LES DI [RightP]
CMP SI, [ES: BX + DI]
OF POP
{cmp ist, [Rechts + bx Offset]}
JNE @ Splay8
PUSH AX
MOV AX, SI
LES SI, [LeftP]
ADD SI, AX
MOV DX, [ES: SI]
{mov dx, [Links + sc Offset] {}; führen Sie einen rechten Zick-Zick
} LES SI, [RightP]
MOV [ES: BX + SI], DX
{mov [bx + rechts versetzt], dx}
xchg bx, dx
LES SI, [MOMP]
MOV [ES: BX + SI], DX
{mov dx [Mom + bx Offset]}
LES SI, [LeftP]
ADD SI, DI
MOV BX, [ES: SI]
{mov bx, [Offset + links]}
LES SI, [RightP]
ADD SI, AX
MOV [ES: SI], BX
{mov [Offset Rechts + SI], bx}
LES SI, [MOMP]
MOV [ES: BX + SI], AX
{mov, sc [Mom + bx Offset]}
mov bx, dx
LES SI, [LeftP]
ADD SI, AX
MOV [ES: SI], BX
{mov [Offset Links + si], bx}
LES SI, [LeftP]
ADD SI, DI
MOV [ES: SI], AX
{mov [Offset Left +], SI}
LES SI, [MOMP]
MOV [ES: BX + SI], AX
{mov, sc [Mom + bx Offset]}
LES SI, [MOMP]
ADD SI, AX
MOV [ES: SI], DI
{mov [Offset Mutter + si], für}
MOV SI, AX
POP AX
JMP @ Splay9
@ Splay8:
PUSH AX
MOV AX, SI
LES SI, [RightP]
ADD SI, DI
MOV DX, [ES: SI]
{mov dx, [Offset + Recht] {}; führen Sie einen rechten Zick-Zack-
} LES SI, [LeftP]
MOV [ES: BX + SI], DX
{mov [bx + links Offset], dx}
xchg bx, dx
LES SI, [MOMP]
MOV [ES: BX + SI], DX
{mov dx [Mom + bx Offset]}
LES SI, [LeftP]
ADD SI, DI
MOV BX, [ES: SI]
{mov bx, [Offset + links]}
LES SI, [RightP]
ADD SI, AX
MOV [ES: SI], BX
{mov [Offset Rechts + SI], bx}
LES SI, [MOMP]
MOV [ES: BX + SI], AX
{mov, sc [Mom + bx Offset]}
mov bx, dx
LES SI, [RightP]
ADD SI, DI
MOV [ES: SI], BX
{mov [+ Rechts der Offset], bx}
LES SI, [LeftP]
ADD SI, DI
MOV [ES: SI], AX
{mov [Offset Left +], SI}
LES SI, [MOMP]
ADD SI, AX
MOV [ES: SI], DI
LES SI, [MOMP]
MOV [ES: BX + SI], DI
{mov [Mama + si Offset], für
mov [bx + Offset Mutter]} von
MOV SI, AX
POP AX
@ Splay9: mov si, cx
cmp ist, NUL
ja @ Splay10
PUSH TO
LES DI [LeftP]
ADD DI, SI
CMP BX, [ES: DI]
OF POP
{cmp bx, [Offset + wird links]}
JNE @ Splay10
PUSH BX
LES BX, [LeftP]
MOV [ES: BX + SI], DI
POP BX
{mov [Offset + wird links], der}
JMP @ Splay11
@ Splay10:
PUSH BX
LES BX, [RightP]
MOV [ES: BX + SI], DI
POP BX
{mov [Offset Rechts + SI]} von
@ Splay11:
PUSH BX
LES BX, [MOMP]
MOV [ES: BX + DI], SI
POP BX
{mov [Offset Mom +], SI}
JMP @ Splay1
Ende:
Ende; {} Splay

InsertNode Verfahren; Assembler;
{
InsertNode: Legen Sie die neuen Knoten, der dem Baum. Beachten Sie, dass l '
Position einer Zeichenfolge im Puffer diente auch als Knoten
Nummer.
ENTRY: = Ort des Puffers
}
Asm
Push SI
Push dx
Push cx
Push bx
mov dx, 1
xor Axt, Axt
mov MatchLen, Axt
Höhe mov ax
LES SI, [TextBufP]
ADD SI, DI
MOV AL, BYTE PTR [ES: SI]
{mov al, byte ptr [Offset + TextBuf von]}
SHL, 1
hinzufügen Axt, N + 1
Axt SHL, 1
mov si, Axt
mov ax, NUL
PUSH BX
LES BX, [RightP]
MOV WORD PTR [ES: BX + DI], AX
{mov Wort ptr [Offset von + Rechts], ax}
LES BX, [LeftP]
MOV WORD PTR [ES: BX + DI], AX
POP BX
{mov Wort ptr [Offset + left], ax}
@ INS1: Höhe inc
cmp dx, 0
jl @ INS3
PUSH TO
LES DI [RightP]
ADD DI, SI
MOV AX, WORD PTR [ES: DI]
OF POP
{mov ax, word ptr [Rechts + si Offset]}
cmp ax, NUL
JE @ INS2
mov si, Axt
JMP @ INS5
@ INS2:
PUSH BX
LES BX, [RightP]
MOV WORD PTR [ES: BX + SI], DI
{mov Wort ptr [Offset Rechts + SI]} von
LES BX, [MOMP]
MOV WORD PTR [ES: BX + DI], SI
POP BX
{mov Wort ptr [Offset + Mutter] SI}
JMP @ Ins11
@ INS3:
PUSH BX
LES BX, [LeftP]
ADD BX, SI
MOV AX, WORD PTR [ES: BX]
POP BX
{mov ax, word ptr [Offset + wird links]}
cmp ax, NUL
JE @ INS4
mov si, Axt
JMP @ INS5
@ INS4:
PUSH BX
LES BX, [LeftP]
ADD BX, SI
MOV WORD PTR [ES: BX] DI
{mov Wort ptr [Offset + wird links], der}
LES BX, [MOMP]
ADD BX, DI
MOV WORD PTR [ES: BX], SI
POP BX
{mov Wort ptr [Offset + Mutter] SI}
JMP @ Ins11
@ INS5: mov bx, 1
shr ist, 1
shr von 1
xor ch, ch
xor DH, DH
@ INS6:
PUSH SI
LES SI, [TextBufP]
ADD SI, DI
MOV DL, BYTE PTR [ES: BX + SI]
POP SI
PUSH TO
LES DI [TextBufP]
ADD DI, SI
MOV CL, BYTE PTR [ES: BX + DI]
OF POP
{mov dl, byte ptr [Offset Textbuf + von + bx]
mov cl, byte ptr [Offset TextBuf + Sie + bx]}
Unter dx, cx
jnz @ INS7
inc bx
cmp bx, F
jb @ INS6
@ INS7: SHL ist, 1
SHL, 1
cmp bx, MatchLen
JBE @ INS1
mov ax, SI
shr ax, 1
matchPos mov ax
mov MatchLen, bx
cmp bx, F
jb @ INS1
@ INS8:
PUSH CX
LES BX, [MOMP]
MOV AX, WORD PTR [ES: BX + SI]
{mov ax, word ptr [Mama + si Offset]}
LES BX, [MOMP]
MOV WORD PTR [ES: BX + DI], AX
{mov Wort ptr, Axt [+ Mutter von Offset]}
LES BX, [LeftP]
MOV CX, WORD PTR [ES: BX + SI]
{mov bx, Wort ptr [Offset + wird links]}
LES BX, [LeftP]
MOV WORD PTR [ES: BX + DI], CX
{mov Wort ptr [Offset + left], bx}
LES BX, [MOMP]
ADD BX, CX
MOV WORD PTR [ES: BX] DI
von {mov Wort ptr [Mama + bx Offset]}
LES BX, [RightP]
MOV CX, WORD PTR [ES: BX + SI]
{mov bx, Wort ptr [Rechts + si Offset]}
LES BX, [RightP]
MOV WORD PTR [ES: BX + DI], CX
{mov Wort ptr [Offset von + Rechts], bx}
LES BX, [MOMP]
Ende;


{


} die rechte
Ende;

}
Ende;


Ende;


Start
Start
Ende
Ende;


Start
Start
Ende
Ende;


Start
Start


Ende
Ende;


Start
Start


Ende
Ende;

weit weg;
Ende;
{$ ENDIF}

Start
{$ ENDIF}


Ende;

weit weg;
Start
Ende;


Ende;

Start
Start
Ende;
Start
Ende;
Start
Start
mehr

(0)
(0)

Kommentare - 0

Keine Kommentare

Fügen Sie einen Kommentar

smile smile smile smile smile smile smile smile
smile smile smile smile smile smile smile smile
smile smile smile smile smile smile smile smile
smile smile smile smile
Zeichen übrig: 3000
captcha