d7zip / sevenzip.pas von mail2nnv - Fragen zur Funktionsweise, DictionarySize, ...

[DieDolly]

Ich gehe gerade weg von JclCompression hin zu einem anderen ebenfalls kostenlosen Wrapper für die 7z.dll.
Dabei ist der aktuellsten den ich finden kann ein Fork vom originalen d7zip von mail2nnv https://github.com/mail2nnv/d7zip

Ich habe den ein wenig angepasst
- AddBk ist weg es gibt jetzt nur noch den SysUtils-Aufruf IncludeTrailingPathDelimiter
- ForceDirectories auch weg, nur noch SysUtils direkt
- SetDateTimeFile wurde durch TFile.SetCreationTime() ersetzt
- LZMA habe ich aus TZipCompressionMethod entfernt, da das scheinbar inkompatibel ist?

Das funktioniert soweit ganz gut. Aber ich habe noch keine Ahnung, was für Werte bei SetDictionarySize einzufügen sind. Bei 7z ist 63 die Obergrenze, bei Zip 32. Alles andere knallt.

Hier mein erster Versuch der funktioniert. Das ist jetzt nur alles reingeschrieben, keine Benutzeroberfläche (nur ein Button und eine ProgressBar). Es geht nur um den Test.
Wie funktioniet das mit der Wörterbuchgröße? In dieser Dokumentation wird von ganz anderen Werten gesprochen https://sevenzip.osdn.jp/chm/cmdline...DictionarySize

Was ich auch nicht verstehe:
- Kompressionsverfahren ist Copy, Kompressionsstärke 0 (Speichern). Wenn ich bei 7z die sonstigen Optionen auslassen, wird das Archiv auch nicht komprimiert. Schalte ich aber Multithreading dazu, wird es trotzdem komprimiert
- schalte ich alle Optionen ab und nur SetDictionnarySize() an, gibt es einen Fehler bei der Bereichsprüfung. Setze ich den Wert einfach mal auf 1, geht es. Aber woher soll ich das Maximum wissen?
Verwende ich das falsch?

Delphi-Quellcode:

function ProgressCallback(Sender: Pointer; Total: Boolean; Value: Int64): HRESULT; stdcall;
begin
 BytesCopied := Value; // Test

 if Total then
  Form1.ProgressBar1.Max := 100
 else
  Form1.ProgressBar1.Position := GetPercent(BytesToCopy, BytesCopied);

 Result := S_OK;
end;

function CompressionStrength(cs: TCompressStrength): Cardinal;
begin
 case cs of
  SAVE:
   Result := 0;
  FASTEST:
   Result := 1;
  FAST:
   Result := 3;
  NORMAL:
   Result := 5;
  MAXIMUM:
   Result := 7;
  ULTRA:
   Result := 9;
 else
  Result := 5;
 end;
end;

procedure X;
begin
var
 Archivformat: TGUID;
 Archivename: string;
 Arch: I7zOutArchive;
begin
 Archivformat := CLSID_CFormat7z;
 Arch := CreateOutArchive(Archivformat);

 Archivename := 'archive.7z';

 // Add a progress bar ...
 Arch.SetProgressCallback(nil, ProgressCallback);

 Arch.AddFile('1.mp4', '1.mp4');
 Arch.AddFile('2.mp4', '2.mp4');
 BytesToCopy := TFile.GetSize('1.mp4') + TFile.GetSize('2.mp4'); // Test

 // Compression level 0-9
 SetCompressionLevel(Arch, CompressionStrength(TCompressStrength.ULTRA));

 // 7z options
 if Archivformat = CLSID_CFormat7z then
  begin
   // ==============================================================================================================================================
   // Compression method
   SevenZipSetCompressionMethod(Arch, T7zCompressionMethod.m7LZMA);

   // Multithreading
   SetMultiThreading(Arch, CPUCount);

   // Compress headers
   SevenZipCompressHeaders(Arch, True);

   SetDictionnarySize(Arch, 63); // 0-63

   // Encrypt headers
   SevenZipEncryptHeaders(Arch, True);

   // Encrpytion method is always AES265
   // ==============================================================================================================================================
  end
 else
  // ZIP options
  if Archivformat = CLSID_CFormatZip then
   begin
    // ==============================================================================================================================================
    // Compression method (LZMA not available)
    SetCompressionMethod(Arch, TZipCompressionMethod.mzBZip2);

    // Multithreading
    SetMultiThreading(Arch, CPUCount);

    // Dictionnary size
    SetDictionnarySize(Arch, 32); // 0-32

    // Encryption method
    SetEncryptionMethod(Arch, TZipEncryptionMethod.emAES256);

    // Number deflate passes
    SetDeflateNumPasses(Arch, 2); // 1-?

    // Number fast bytes
    SetNumFastBytes(Arch, 256); // max 0-?
    // ==============================================================================================================================================
   end;

  // Set a password if necessary
  Arch.SetPassword('password');

  // Save to file
  Arch.SaveToFile(Archivename);
 end;

Procedure SetCompressionLevel abgeändert in das da unten funktioniert auch nicht. Immer Fehler Bereichsprüfung.

Delphi-Quellcode:

procedure SetCompressionLevel(Arch: I7zOutArchive; level: Cardinal);
begin
  SetCardinalProperty(arch, 'X', level);
  
  // TEST

  if level <= 9 then
   begin
    if level >= 9 then
     SetDictionnarySize(Arch, kLzmaDicSizeX9)
    else if level >= 7 then
     SetDictionnarySize(Arch,  kLzmaDicSizeX7)
    else if level >= 5 then
     SetDictionnarySize(Arch,  kLzmaDicSizeX5)
    else if level >= 3 then
     SetDictionnarySize(Arch,  kLzmaDicSizeX3)
    else
     SetDictionnarySize(Arch, kLzmaDicSizeX1);
   end
  else
   raise Exception.Create(RsCompressionUnavailableProperty);
end;

[KodeZwerg]

Ich habe mal eine Test-Anwendung erstellt.
Bei weitem nicht fertig, aber so das grundlegende funktioniert.
Es kann für x86 oder x64 kompiliert werden.
Es kann mehrere Dateien aufnehmen.
Es kann alle Unterstützten Methoden anwenden.
Es kann alle Kompressions-Stufen verarbeiten.

Es zeigt keinen Status.
Es legt die Dateien mit einem absoluten Pfad an

Es funktioniert

Alle benötigten Dateien für das Projekt sind enthalten, auch die 7-Zip Bibliotheken.

[KodeZwerg]

Ps: DieDolly, les doch mal was da im sevenzip.pas steht, da wird dir doch per X gezeigt was erlaubt ist und was nicht.
Also das was du möchtest, SetDictionnarySize, ist nur für das Zip und BZip2 format (CLSID_CFormatZip, CLSID_CFormatBZ2) verfügbar.

Code:

                                                                                             //  ZIP 7z GZIP BZ2
  procedure SetCompressionLevel(Arch: I7zOutArchive; level: Cardinal);                        //   X   X   X   X
  procedure SetMultiThreading(Arch: I7zOutArchive; ThreadCount: Cardinal);                    //   X   X       X

  procedure SetCompressionMethod(Arch: I7zOutArchive; method: TZipCompressionMethod);         //   X
  procedure SetEncryptionMethod(Arch: I7zOutArchive; method: TZipEncryptionMethod);           //   X
  procedure SetDictionnarySize(Arch: I7zOutArchive; size: Cardinal); // < 32                 //   X           X
  procedure SetMemorySize(Arch: I7zOutArchive; size: Cardinal);                               //   X
  procedure SetDeflateNumPasses(Arch: I7zOutArchive; pass: Cardinal);                         //   X       X   X
  procedure SetNumFastBytes(Arch: I7zOutArchive; fb: Cardinal);                               //   X       X
  procedure SetNumMatchFinderCycles(Arch: I7zOutArchive; mc: Cardinal);                       //   X       X


  procedure SevenZipSetCompressionMethod(Arch: I7zOutArchive; method: T7zCompressionMethod);  //       X
  procedure SevenZipSetBindInfo(Arch: I7zOutArchive; const bind: UnicodeString);              //       X
  procedure SevenZipSetSolidSettings(Arch: I7zOutArchive; solid: boolean);                    //       X
  procedure SevenZipRemoveSfxBlock(Arch: I7zOutArchive; remove: boolean);                     //       X
  procedure SevenZipAutoFilter(Arch: I7zOutArchive; auto: boolean);                           //       X
  procedure SevenZipCompressHeaders(Arch: I7zOutArchive; compress: boolean);                  //       X
  procedure SevenZipCompressHeadersFull(Arch: I7zOutArchive; compress: boolean);              //       X
  procedure SevenZipEncryptHeaders(Arch: I7zOutArchive; Encrypt: boolean);                    //       X
  procedure SevenZipVolumeMode(Arch: I7zOutArchive; Mode: boolean);                           //       X

[KodeZwerg]

Nach längerem testen habe ich festgestellt das die alte API inkompatibel zu den Bibliotheken ist.
Es wurde zwar kein Fehler gemeldet aber stur nur mit LZMA archiviert.
Im Anhang sind für x86 und x64 funktionierende Bibliotheken und Test-Anwendungen.
Merkwürdiger weise interessiert es der dll nicht welche Kompressionslevel ich angebe aber die Methoden funktionieren nun.
Die BZip2 Methode lässt bei mir die Applikation einfrieren, der Rest funktioniert.
Die Test-Anwendungen sind nun (abgesehen vom BZip2 und das ignorieren des Levels) stabil.
Die Datei Liste wurde überarbeitet und lässt keine doppelten Dateien mehr zu. (nur wenn sie aus verschiedenen Verzeichnissen abstammen)
Drag und Drop aus dem Explorer für Dateien oder Verzeichnisse wurde integriert.
In den Archiven wird nun der Pfad korrekt abgelegt, es wird aus allen Dateien der niedrigste gemeinsame Pfad ermittelt und im Archiv verwendet.
Passwort Verschlüsselung und Anzahl der Threads wurde hinzugefügt.

[DieDolly]

Danke für die Demo und das Testen.

Es muss doch eine andere Möglichkeit geben, um bzip2, deflate usw zum Laufen zu bekommen. Eine DLL von 2009 kann nicht die Lösung sein.
Die API setzt das Property 0 (Null) für die Kompressionsmethode. Vielleicht ist das veraltet bzw. die Namensgebung SevCompressionMethod: array[T7zCompressionMethod] of UnicodeString = ('COPY', 'LZMA', 'BZIP2', 'PPMD', 'DEFLATE', 'DEFLATE64');
Für das LZMA-Problem habe ich eine Lösung. In der SetMultithreading-Prozedur steht normalerweise

Delphi-Quellcode:

procedure SetMultiThreading(Arch: I7zOutArchive; ThreadCount: Cardinal);
begin
 SetCardinalProperty(arch, 'MT', ThreadCount);
end;

Das abgeändert zu dem hier und das LZMA-Problem ist weg

Delphi-Quellcode:

procedure SetMultiThreading(Arch: I7zOutArchive; ThreadCount: Cardinal);
begin
 // SetCardinalProperty(arch, 'MT', ThreadCount);

 if ThreadCount > 1 then
  SetCardinalProperty(arch, 'MT', ThreadCount)
 else if ThreadCount <= 0 then
  SetBooleanProperty(arch, 'MT', False);
end;

Das Problem liegt also bei 7z selbst.

Vielleicht hilft die Community ja mit, dass Delphi endlich eine sehr gut funktionierende 7z-DLL-API bekommt. Die von Jedi in allen Ehren, aber die ist nix.

Was mir auch aufgefallen ist:
- Kompressionslevel SAVE und Kompressionsmethode COPY funktionieren nur im Single-Threaded-Modus
-- funktionieren außerdem nur, wenn EncryptHeaders nicht an ist. Ist EncryptHeaders an, sind wir wieder beim LZMA-Problem.

Die hier vorgestellte API schreibt die 7z Kompressionsmethode ins Property 0 (Null). Ich weiß nicht wie aktuell diese Seite ist, aber hier ist die Rede vom Property N https://sevenzip.osdn.jp/chm/cmdline...d.htm#MethodID

Will man das machen kommt aber wieder nur, wie immer "Fehler bei Bereichsprüfung"

[KodeZwerg]

Zitat von DieDolly:

Danke für die Demo und das Testen.

Gerne!

Zitat von DieDolly:

Es muss doch eine andere Möglichkeit geben, um bzip2, deflate usw zum Laufen zu bekommen. Eine DLL von 2009 kann nicht die Lösung sein.

Naja, die Header sind von 2009, von daher bleibe ich nun auch beim testen bei diesen alten Bibliotheken.

Zitat von DieDolly:

Das Problem liegt also bei 7z selbst.

Oder die Header Übersetzung... Du siehst ja das nicht alles so klappt wie man eigentlich vermuten sollte.

Zitat von DieDolly:

- Kompressionslevel SAVE und Kompressionsmethode COPY funktionieren nur im Single-Threaded-Modus
-- funktionieren außerdem nur, wenn EncryptHeaders nicht an ist. Ist EncryptHeaders an, sind wir wieder beim LZMA-Problem.

Also die 7z.dll macht irgendwie schon das was sie sollte, nur eben nicht alles.
Abgesehen von BZip2, Kompressions Level und Threads, arbeitet es einwandfrei.
Das mit den Threads ist mir erstmal gar nicht so ins Auge gefallen da ich mich mehr auf die erzeugten Archive fokusiert hatte.

Deinen Patch kann ich nicht nachvollziehen.

Delphi-Quellcode:

procedure SetMultiThreading(Arch: I7zOutArchive; ThreadCount: Cardinal);
begin
//  SetCardinalProperty(arch, 'MT', ThreadCount);
 if (ThreadCount > 1) then
   SetCardinalProperty(arch, 'MT', ThreadCount)
 else
   if (ThreadCount <= 0) then
     SetBooleanProperty(arch, 'MT', False);
end;

Macht doch das gleiche wie

Delphi-Quellcode:

procedure SetMultiThreading(Arch: I7zOutArchive; ThreadCount: Cardinal);
begin
  SetCardinalProperty(arch, 'MT', ThreadCount);
end;

(Boolean False wird doch zu einer 0)

So sieht meine "Pack" routine aus:

Delphi-Quellcode:

procedure TfrmMain.btnCreateClick(Sender: TObject);
var
  Arch: I7zOutArchive;
  fn: string;
  i: Integer;
  len: Integer;
begin
  if (lbFiles.Items.Count > 0) then
    if sdCreate.Execute(Self.Handle) then
      begin
        // update UI
        btnAdd.Enabled := False;
        btnClear.Enabled := False;
        edtPassword.Enabled := False;
        gbLevel.Enabled := False;
        rgMethod.Enabled := False;
        cbThreads.Enabled := False;
        cbThread.Enabled := False;
        Application.ProcessMessages;
        Sleep(1);
        // begin creating internal archive format
        Arch := CreateOutArchive(CLSID_CFormat7z);
        // store filename
        fn := sdCreate.FileName;
        // calculate the number of chars to be stripped
        if (lbFiles.Items.Count > 1) then
          len := Succ(Length(FindCommonPath(PathDelim, lbFiles.Items.ToStringArray)));
        // compression level 0-9 (store - ultra)
        SetCompressionLevel(Arch, tbLevel.Position);
        // compression method
        case rgMethod.ItemIndex of
          0: SevenZipSetCompressionMethod(Arch, m7Copy);
          1: SevenZipSetCompressionMethod(Arch, m7LZMA);
          2: SevenZipSetCompressionMethod(Arch, m7BZip2);
          3: SevenZipSetCompressionMethod(Arch, m7PPMd);
          4: SevenZipSetCompressionMethod(Arch, m7Deflate);
          5: SevenZipSetCompressionMethod(Arch, m7Deflate64);
          else
            SevenZipSetCompressionMethod(Arch, m7Copy);
        end;
        // number of threads
        if ((not cbThread.Checked) and (cbThreads.Items.Strings[0] <> 'N/A')) then
          SetMultiThreading(Arch, Succ(cbThreads.ItemIndex))
        else
          SetMultiThreading(Arch, 0);
        // optional try archive settings
        SevenZipRemoveSfxBlock(Arch, True);
        SevenZipSetSolidSettings(Arch, True);
        SevenZipAutoFilter(Arch, True);
        SevenZipCompressHeaders(Arch, True);
        SevenZipCompressHeadersFull(Arch, True);
        SevenZipEncryptHeaders(Arch, True);
        // optional password encrypt
        if (edtPassword.Text <> '') then
          Arch.SetPassword(edtPassword.Text);
        // use progressbar
        Arch.SetProgressCallback(Self, ProgressCallback);
        // add files to archive, stripping leading folders
        if (lbFiles.Items.Count = 1) then
          Arch.AddFile(lbFiles.Items.Strings[0], ExtractFileName(lbFiles.Items.Strings[0]))
        else
          for i := 0 to Pred(lbFiles.Items.Count) do
            Arch.AddFile(lbFiles.Items.Strings[i], Copy(lbFiles.Items.Strings[i], Succ(len), (Length(lbFiles.Items.Strings[i]) - len)));
        // encode and write the archive
        Arch.SaveToFile(fn);
        // update UI
        btnAdd.Enabled := True;
        btnClear.Enabled := True;
        edtPassword.Enabled := True;
        gbLevel.Enabled := True;
        cbThread.Enabled := True;
        cbThreads.Enabled := ((not cbThread.Checked) and (cbThreads.Items.Strings[0] <> 'N/A'));
        rgMethod.Enabled := True;
        Application.ProcessMessages;
      end;
end;

[DieDolly]

Zitat:

Deinen Patch kann ich nicht nachvollziehen.
Macht doch das gleiche wie

Der Patch ist direkt von SourceForge. Wenn man MT auf 0 setzt, ist es nicht zwangsweise auf Off gesetzt. Das macht der Patch.

Ich würde mir sehr wünschen, dass es aktuelle Header gibt. Die von Jedi sind halt auch nicht gut. Mit den Jedis kann man nur bei Zip-Archiven die Kompressionsmethode wählen, bei 7z nicht.
Ich würde das ja erweitern, aber JclCompression ist eine einzige Katastrophe. Deswegen dachte ich an diese Bibliothek von https://github.com/mail2nnv/d7zip, welche letztes Jahr erst abgeändert wurde.

Für Delphi scheint es einfach nichts Brauchbares zu geben.

Tun wir uns doch zusammen, und bauen mal etwas, was heute funktioniert - eine funktionierende, von der DelphiPraxis ins Leben gerufene Delphi 7z-Bibliothek.

[DieDolly]

Ich habe ChatGPT mal gefragt ob das Ding helfen kann, aber die Antworten sind zu 75% falsch. Es werden Units eingebunden, die nichts mit der mit Delphi mitgelieferten sevenzip.pas oder mit der hier vorgestellten Bibliothek zu tun haben.

[dummzeuch]

Ich hatte gehofft, dass das einfach eine C API ist, aber anscheinend benutzt es Interfaces, die "irgendwie" initialisiert werden müssen (laut readme.txt im DOCS-Verzeichnis). Das ist mir auf die Schnelle zu komplex. d7zip macht das anscheinend auch.

Ich hätte nämlich definitiv Interesse an einer funtionierenden Import-Unit für die 7z.dll, da ich nach meinem Urlaub damit große Dateien ein- und auspacken wollte, und zwar idealerweise mit bzip2.
(Für ZIP funktionieren die jcl-Units problemlos, die verwenden wir schon seit Ewigkeiten.)

[DieDolly]

Genau, ZIP ist OK. Da kann man auch die Kompressionsmethode aussuchen. Bei 7z hört es dann aber schon auf, das ist wie ich finde eine grundlegende Option, die JclCompression nicht bietet.
Ja, ein Wunschtraum. Eine funktionierende, aktuelle Schnittstelle, damit man die 7z.dll richtig nutzen kann.
Ich kann es leider nicht, weil ich keine Ahnung habe. Aber warum scheint das Thema so uninteressant zu sein? Es gibt große Komponenten, ja. Aber 7z.dll ist einfach das Beste was man nutzen kann.